protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList<OutputTO> outputs = new List<OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var outputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update));
colItr.AddVariableToIterateOn(outputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if(dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(OutputPath, "File or Folder", dataObject.Environment, update));
AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Destination Private Key File", dataObject.Environment, update);
}
}
while(colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
Dev2CRUDOperationTO opTo = new Dev2CRUDOperationTO(Overwrite);
try
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(outputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Create(dstEndPoint, opTo, true);
outputs.Add(DataListFactory.CreateOutputTO(Result, result));
}
catch(Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
allErrors.AddError(e.Message);
break;
}
}
return outputs;
}
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList<OutputTO> outputs = new List<OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if(dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update);
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if(!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
}
while(colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endpoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
string result = broker.Get(endpoint);
outputs[0].OutputStrings.Add(result);
}
catch(Exception e)
{
outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return outputs;
}
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors)
{
IList<OutputTO> outputs = new List<OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(Password));
colItr.AddVariableToIterateOn(passItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if(dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment);
AddDebugInputItemUserNamePassword(dataObject.Environment);
}
while(colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
try
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Delete(dstEndPoint);
outputs[0].OutputStrings.Add(result);
}
catch(Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
//outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return outputs;
}
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList<OutputTO> outputs = new List<OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
var contentItr =new WarewolfIterator(dataObject.Environment.Eval(FileContents, update));
colItr.AddVariableToIterateOn(contentItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if(dataObject.IsDebugMode())
{
AddDebugInputItem(OutputPath, "Output Path", dataObject.Environment, update);
AddDebugInputItem(new DebugItemStaticDataParams(GetMethod(), "Method"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
AddDebugInputItem(FileContents, "File Contents", dataObject.Environment, update);
}
while(colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
var writeType = GetCorrectWriteType();
Dev2PutRawOperationTO putTo = ActivityIOFactory.CreatePutRawOperationTO(writeType, TextUtils.ReplaceWorkflowNewLinesWithEnvironmentNewLines(colItr.FetchNextValue(contentItr)));
IActivityIOPath opath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(opath);
try
{
if(allErrors.HasErrors())
{
outputs[0].OutputStrings.Add(null);
}
else
{
string result = broker.PutRaw(endPoint, putTo);
outputs[0].OutputStrings.Add(result);
}
}
catch(Exception e)
{
outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return outputs;
}
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IsNotCertVerifiable = true;
allErrors = new ErrorResultTO();
IList<OutputTO> outputs = new List<OutputTO>();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if(dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update);
AddDebugInputItem(new DebugItemStaticDataParams(GetReadType().GetDescription(), "Read"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
}
while(colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
IList<IActivityIOPath> listOfDir = broker.ListDirectory(endPoint, GetReadType());
if(DataListUtil.IsValueRecordset(Result) && DataListUtil.GetRecordsetIndexType(Result) != enRecordsetIndexType.Numeric)
{
if(DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
string recsetName = DataListUtil.ExtractRecordsetNameFromValue(Result);
string fieldName = DataListUtil.ExtractFieldNameFromValue(Result);
int indexToUpsertTo = 1;
if(listOfDir != null)
{
foreach(IActivityIOPath pa in listOfDir)
{
string fullRecsetName = DataListUtil.CreateRecordsetDisplayValue(recsetName, fieldName,
indexToUpsertTo.ToString(CultureInfo.InvariantCulture));
outputs.Add(DataListFactory.CreateOutputTO(DataListUtil.AddBracketsToValueIfNotExist(fullRecsetName), pa.Path));
indexToUpsertTo++;
}
}
}
else if(DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Blank)
{
if(listOfDir != null)
{
foreach(IActivityIOPath pa in listOfDir)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, pa.Path));
}
}
}
}
else
{
if(listOfDir != null)
{
string xmlList = string.Join(",", listOfDir.Select(c => c.Path));
outputs.Add(DataListFactory.CreateOutputTO(Result));
outputs.Last().OutputStrings.Add(xmlList);
}
}
}
catch(Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(null));
allErrors.AddError(e.Message);
break;
}
}
return outputs;
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
_debugInputs = new List <DebugItem>();
allErrors = new ErrorResultTO();
IList <OutputTO> outputs = new List <OutputTO>();
var colItr = new WarewolfListIterator();
var sharepointSource = ResourceCatalog.GetResource <SharepointSource>(dataObject.WorkspaceID, SharepointServerResourceId);
if (sharepointSource == null)
{
sharepointSource = SharepointSource;
SharepointServerResourceId = sharepointSource.ResourceID;
}
ValidateRequest();
var serverInputItr = new WarewolfIterator(dataObject.Environment.Eval(ServerInputPath, update));
colItr.AddVariableToIterateOn(serverInputItr);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(ServerInputPath, "ServerInput Path", dataObject.Environment, update);
}
while (colItr.HasMoreData())
{
try
{
var serverPath = colItr.FetchNextValue(serverInputItr);
if (DataListUtil.IsValueRecordset(Result) && DataListUtil.GetRecordsetIndexType(Result) != enRecordsetIndexType.Numeric)
{
if (DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
string recsetName = DataListUtil.ExtractRecordsetNameFromValue(Result);
string fieldName = DataListUtil.ExtractFieldNameFromValue(Result);
var result = Delete(sharepointSource, serverPath);
int indexToUpsertTo = 1;
foreach (var file in result)
{
string fullRecsetName = DataListUtil.CreateRecordsetDisplayValue(recsetName, fieldName,
indexToUpsertTo.ToString(CultureInfo.InvariantCulture));
outputs.Add(DataListFactory.CreateOutputTO(DataListUtil.AddBracketsToValueIfNotExist(fullRecsetName), file));
indexToUpsertTo++;
}
}
else if (DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Blank)
{
var result = Delete(sharepointSource, serverPath);
foreach (var folder in result)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, folder));
}
}
}
else
{
var result = Delete(sharepointSource, serverPath);
string xmlList = string.Join(",", result.Select(c => c));
outputs.Add(DataListFactory.CreateOutputTO(Result));
outputs.Last().OutputStrings.Add(xmlList);
}
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(null));
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
private static IEnumerable <TestRunResult> GetTestRunResults(IDSFDataObject dataObject, IServiceTestOutput output, Dev2DecisionFactory factory, IDebugState debugState)
{
if (output == null)
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.None
};
return(new List <TestRunResult> {
testResult
});
}
if (string.IsNullOrEmpty(output.Variable) && string.IsNullOrEmpty(output.Value))
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.None
};
output.Result = testResult;
return(new List <TestRunResult> {
testResult
});
}
if (output.Result != null)
{
output.Result.RunTestResult = RunResult.TestInvalid;
}
if (string.IsNullOrEmpty(output.Variable))
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.TestInvalid,
Message = Messages.Test_NothingToAssert
};
output.Result = testResult;
if (dataObject.IsDebugMode())
{
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(testResult.Message, true);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugState.AssertResultList.Add(itemToAdd);
}
return(new List <TestRunResult> {
testResult
});
}
IFindRecsetOptions opt = FindRecsetOptions.FindMatch(output.AssertOp);
var decisionType = DecisionDisplayHelper.GetValue(output.AssertOp);
var value = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.Value)
};
var from = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.From)
};
var to = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.To)
};
IList <TestRunResult> ret = new List <TestRunResult>();
var iter = new WarewolfListIterator();
var cols1 = dataObject.Environment.EvalAsList(DataListUtil.AddBracketsToValueIfNotExist(output.Variable), 0);
var c1 = new WarewolfAtomIterator(cols1);
var c2 = new WarewolfAtomIterator(value);
var c3 = new WarewolfAtomIterator(@from);
if (opt.ArgumentCount > 2)
{
c2 = new WarewolfAtomIterator(to);
}
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var val1 = iter.FetchNextValue(c1);
var val2 = iter.FetchNextValue(c2);
var val3 = iter.FetchNextValue(c3);
var assertResult = factory.FetchDecisionFunction(decisionType).Invoke(new[] { val1, val2, val3 });
var testResult = new TestRunResult();
if (assertResult)
{
testResult.RunTestResult = RunResult.TestPassed;
}
else
{
testResult.RunTestResult = RunResult.TestFailed;
var msg = DecisionDisplayHelper.GetFailureMessage(decisionType);
var actMsg = string.Format(msg, val2, output.Variable, val1, val3);
testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
}
if (dataObject.IsDebugMode())
{
var msg = testResult.Message;
if (testResult.RunTestResult == RunResult.TestPassed)
{
msg = Messages.Test_PassedResult;
}
var hasError = testResult.RunTestResult == RunResult.TestFailed;
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(msg, hasError);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
if (debugState.AssertResultList != null)
{
bool addItem = debugState.AssertResultList.Select(debugItem => debugItem.ResultsList.Where(debugItemResult => debugItemResult.Value == Messages.Test_PassedResult)).All(debugItemResults => !debugItemResults.Any());
if (addItem)
{
debugState.AssertResultList.Add(itemToAdd);
}
}
}
output.Result = testResult;
ret.Add(testResult);
}
return(ret);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
AddScriptSourcePathsToList();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
var env = dataObject.Environment;
InitializeDebug(dataObject);
try
{
if (!errors.HasErrors())
{
if (dataObject.IsDebugMode())
{
var language = ScriptType.GetDescription();
AddDebugInputItem(new DebugItemStaticDataParams(language, "Language"));
AddDebugInputItem(new DebugEvalResult(Script, "Script", env, update));
}
allErrors.MergeErrors(errors);
if (allErrors.HasErrors())
{
return;
}
var scriptItr = new WarewolfIterator(dataObject.Environment.Eval(Script, update, false, EscapeScript));
while (scriptItr.HasMoreData())
{
var engine = new ScriptingEngineRepo().CreateEngine(ScriptType, _sources);
var value = engine.Execute(scriptItr.GetNextValue());
foreach (var region in DataListCleaningUtils.SplitIntoRegions(Result))
{
env.Assign(region, value, update);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(region))
{
AddDebugOutputItem(new DebugEvalResult(region, "", env, update));
}
}
}
}
}
}
catch (Exception e) when(e is NullReferenceException || e is RuntimeBinderException)
{
if (e.GetType() == typeof(NullReferenceException) || e.GetType() == typeof(RuntimeBinderException))
{
allErrors.AddError(ErrorResource.ScriptingErrorReturningValue);
}
else
{
allErrors.AddError(e.Message.Replace(" for main:Object", string.Empty));
}
}
finally
{
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfScriptingPythonActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
if (allErrors.HasErrors())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
var env = dataObject.Environment;
InitializeDebug(dataObject);
try
{
if (!errors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugInputItem(Length, From, To, dataObject.Environment, RandomType, update);
}
IWarewolfIterator lengthItr = !String.IsNullOrEmpty(Length) ? new WarewolfIterator(env.EvalStrict(Length, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
var fromItr = !String.IsNullOrEmpty(From) ? new WarewolfIterator(env.EvalStrict(From, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
var toItr = !String.IsNullOrEmpty(To) ? new WarewolfIterator(env.EvalStrict(To, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
WarewolfListIterator colItr = new WarewolfListIterator();
colItr.AddVariableToIterateOn(lengthItr);
colItr.AddVariableToIterateOn(fromItr);
colItr.AddVariableToIterateOn(toItr);
Dev2Random dev2Random = new Dev2Random();
while (colItr.HasMoreData())
{
int lengthNum = -1;
double fromNum = -1.0;
double toNum = -1.0;
string fromValue = colItr.FetchNextValue(fromItr);
string toValue = colItr.FetchNextValue(toItr);
string lengthValue = colItr.FetchNextValue(lengthItr);
if (RandomType != enRandomType.Guid)
{
if (RandomType == enRandomType.Numbers)
{
#region Getting the From
fromNum = GetFromValue(fromValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
#region Getting the To
toNum = GetToValue(toValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
else
{
#region Getting the Length
lengthNum = GetLengthValue(lengthValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
}
string value = dev2Random.GetRandom(RandomType, lengthNum, fromNum, toNum);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
env.Assign(Result, value, update);
}
}
}
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFRandomActivity", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfRandomActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IsNotCertVerifiable = true;
allErrors = new ErrorResultTO();
IList <OutputTO> outputs = new List <OutputTO>();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update);
AddDebugInputItem(new DebugItemStaticDataParams(GetReadType().GetDescription(), "Read"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
IList <IActivityIOPath> listOfDir = broker.ListDirectory(endPoint, GetReadType());
if (DataListUtil.IsValueRecordset(Result) && DataListUtil.GetRecordsetIndexType(Result) != enRecordsetIndexType.Numeric)
{
if (DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
string recsetName = DataListUtil.ExtractRecordsetNameFromValue(Result);
string fieldName = DataListUtil.ExtractFieldNameFromValue(Result);
int indexToUpsertTo = 1;
if (listOfDir != null)
{
foreach (IActivityIOPath pa in listOfDir)
{
string fullRecsetName = DataListUtil.CreateRecordsetDisplayValue(recsetName, fieldName,
indexToUpsertTo.ToString(CultureInfo.InvariantCulture));
outputs.Add(DataListFactory.CreateOutputTO(DataListUtil.AddBracketsToValueIfNotExist(fullRecsetName), pa.Path));
indexToUpsertTo++;
}
}
}
else if (DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Blank)
{
if (listOfDir != null)
{
foreach (IActivityIOPath pa in listOfDir)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, pa.Path));
}
}
}
}
else
{
if (listOfDir != null)
{
string xmlList = string.Join(",", listOfDir.Select(c => c.Path));
outputs.Add(DataListFactory.CreateOutputTO(Result));
outputs.Last().OutputStrings.Add(xmlList);
}
}
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(null));
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
IErrorResultTO errors = new ErrorResultTO();
IErrorResultTO allErrors = new ErrorResultTO();
var replacementCount = 0;
var replacementTotal = 0;
InitializeDebug(dataObject);
try
{
IList <string> toSearch = FieldsToSearch.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
AddTypeDebugItem(dataObject, update, toSearch);
foreach (string s in toSearch)
{
if (!DataListUtil.IsEvaluated(s))
{
allErrors.AddError(ErrorResource.RequiredVaraibleNameONLY);
return;
}
}
IWarewolfListIterator iteratorCollection = new WarewolfListIterator();
var finRes = dataObject.Environment.Eval(Find, update);
if (ExecutionEnvironment.IsNothing(finRes))
{
if (!string.IsNullOrEmpty(Result))
{
dataObject.Environment.Assign(Result, replacementTotal.ToString(CultureInfo.InvariantCulture), update);
}
}
else
{
var itrFind = new WarewolfIterator(dataObject.Environment.Eval(Find, update));
iteratorCollection.AddVariableToIterateOn(itrFind);
var itrReplace = new WarewolfIterator(dataObject.Environment.Eval(ReplaceWith, update));
iteratorCollection.AddVariableToIterateOn(itrReplace);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
allErrors = TryExecute(dataObject, update, replaceOperation, ref errors, allErrors, ref replacementCount, ref replacementTotal, toSearch, iteratorCollection, itrFind, itrReplace);
}
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors() && !string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
// now push the result to the server
}
catch (Exception ex)
{
Dev2Logger.Error("DSFReplace", ex, GlobalConstants.WarewolfError);
allErrors.AddError(ex.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfReplaceActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(Result, null, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
var expression = Expression ?? string.Empty;
var roundingDecimalPlaces = RoundingDecimalPlaces ?? string.Empty;
var decimalPlacesToShow = DecimalPlacesToShow ?? string.Empty;
if (dataObject.IsDebugMode())
{
AddDebugInputItem(expression, "Number", dataObject.Environment);
if (!String.IsNullOrEmpty(RoundingType))
{
AddDebugInputItem(new DebugItemStaticDataParams(RoundingType, "Rounding"));
}
AddDebugInputItem(roundingDecimalPlaces, "Rounding Value", dataObject.Environment);
AddDebugInputItem(decimalPlacesToShow, "Decimals to show", dataObject.Environment);
}
var colItr = new WarewolfListIterator();
var expressionIterator = CreateDataListEvaluateIterator(expression, dataObject.Environment);
var roundingDecimalPlacesIterator = CreateDataListEvaluateIterator(roundingDecimalPlaces, dataObject.Environment);
var decimalPlacesToShowIterator = CreateDataListEvaluateIterator(decimalPlacesToShow, dataObject.Environment);
colItr.AddVariableToIterateOn(expressionIterator);
colItr.AddVariableToIterateOn(roundingDecimalPlacesIterator);
colItr.AddVariableToIterateOn(decimalPlacesToShowIterator);
// Loop data ;)
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
while (colItr.HasMoreData())
{
int decimalPlacesToShowValue;
var tmpDecimalPlacesToShow = colItr.FetchNextValue(decimalPlacesToShowIterator);
var adjustDecimalPlaces = tmpDecimalPlacesToShow.IsRealNumber(out decimalPlacesToShowValue);
if (!string.IsNullOrEmpty(tmpDecimalPlacesToShow) && !adjustDecimalPlaces)
{
throw new Exception("Decimals to show is not valid");
}
var tmpDecimalPlaces = colItr.FetchNextValue(roundingDecimalPlacesIterator);
var roundingDecimalPlacesValue = 0;
if (!string.IsNullOrEmpty(tmpDecimalPlaces) && !tmpDecimalPlaces.IsRealNumber(out roundingDecimalPlacesValue))
{
throw new Exception("Rounding decimal places is not valid");
}
var binaryDataListItem = colItr.FetchNextValue(expressionIterator);
var val = binaryDataListItem;
FormatNumberTO formatNumberTo = new FormatNumberTO(val, RoundingType, roundingDecimalPlacesValue, adjustDecimalPlaces, decimalPlacesToShowValue);
var result = _numberFormatter.Format(formatNumberTo);
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
UpdateResultRegions(dataObject.Environment, result);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams(result, Result, "", "="));
}
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFNumberFormatActivity", e);
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfNumberFormatActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
var allErrors = new ErrorResultTO();
try
{
var sharepointSource = ResourceCatalog.GetResource <SharepointSource>(dataObject.WorkspaceID, SharepointServerResourceId);
if (sharepointSource == null)
{
var contents = ResourceCatalog.GetResourceContents(dataObject.WorkspaceID, SharepointServerResourceId);
sharepointSource = new SharepointSource(contents.ToXElement());
}
var env = dataObject.Environment;
if (dataObject.IsDebugMode())
{
AddInputDebug(env, update);
}
ListItemCollection listItems;
var sharepointHelper = sharepointSource.CreateSharepointHelper();
var fields = sharepointHelper.LoadFieldsForList(SharepointList, true);
using (var ctx = sharepointHelper.GetContext())
{
var camlQuery = _sharepointUtils.BuildCamlQuery(env, FilterCriteria, fields, update, RequireAllCriteriaToMatch);
var list = sharepointHelper.LoadFieldsForList(SharepointList, ctx, false);
listItems = list.GetItems(camlQuery);
ctx.Load(listItems);
ctx.ExecuteQuery();
}
using (var ctx = sharepointHelper.GetContext())
{
var list = ctx.Web.Lists.GetByTitle(SharepointList);
foreach (var item in listItems)
{
list.GetItemById(item.Id).DeleteObject();
}
list.Update();
ctx.ExecuteQuery();
}
var successfulDeleteCount = listItems.Count();
if (!string.IsNullOrWhiteSpace(DeleteCount))
{
dataObject.Environment.Assign(DeleteCount, successfulDeleteCount.ToString(), update);
env.CommitAssign();
AddOutputDebug(dataObject, update);
}
}
catch (Exception e)
{
Dev2Logger.Error("SharepointDeleteListItemActivity", e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
DisplayAndWriteError(dataObject, DisplayName, allErrors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
var env = dataObject.Environment;
InitializeDebug(dataObject);
var allErrors = new ErrorResultTO();
try
{
IList <string> toSearch = FieldsToSearch.Split(',');
List <int> results = new List <int>();
if (dataObject.IsDebugMode())
{
AddDebugInputValues(dataObject, toSearch, ref allErrors);
}
bool hasEvaled = false;
foreach (var searchvar in toSearch)
{
Func <DataASTMutable.WarewolfAtom, bool> func = null;
foreach (FindRecordsTO to in ResultsCollection.Where(a => !String.IsNullOrEmpty(a.SearchType)))
{
if ((to.From.Length > 0 && String.IsNullOrEmpty(to.To)) ||
(to.To.Length > 0 && String.IsNullOrEmpty(to.From)))
{
throw new Exception("From and to Must be populated");
}
ValidateRequiredFields(to, out errorsTo);
var right = env.EvalAsList(to.SearchCriteria);
IEnumerable <DataASTMutable.WarewolfAtom> from = new List <DataASTMutable.WarewolfAtom>();
IEnumerable <DataASTMutable.WarewolfAtom> tovalue = new List <DataASTMutable.WarewolfAtom>();
if (!String.IsNullOrEmpty(to.From))
{
@from = env.EvalAsList(to.From);
}
if (!String.IsNullOrEmpty(to.To))
{
tovalue = env.EvalAsList(to.To);
}
if (func == null)
{
func = CreateFuncFromOperator(to.SearchType, right, @from, tovalue);
}
else
{
func = RequireAllTrue ? CombineFuncAnd(func, to.SearchType, right, @from, tovalue) : CombineFuncOr(func, to.SearchType, right, @from, tovalue);
}
}
var output = env.EnvalWhere(dataObject.Environment.ToStar(searchvar), func);
if (RequireAllFieldsToMatch && hasEvaled)
{
results = results.Intersect(output).ToList();
}
else
{
results = results.Union(output).ToList();
}
hasEvaled = true;
}
if (!results.Any())
{
results.Add(-1);
}
var res = String.Join(",", results.Distinct());
env.Assign(Result, res);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
catch (Exception exception)
{
Dev2Logger.Log.Error("DSFRecordsMultipleCriteria", exception);
allErrors.AddError(exception.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfFindRecordsMultipleCriteriaActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(Result, "-1");
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
// ReSharper restore RedundantOverridenMember
/// <summary>
/// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity
/// </summary>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsert.ReplaceStarWithFixedIndex = true;
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
try
{
CleanArgs();
ICaseConverter converter = CaseConverterFactory.CreateCaseConverter();
allErrors.MergeErrors(errors);
int index = 1;
int outIndex = 0;
foreach (ICaseConvertTO item in ConvertCollection)
{
outIndex++;
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
allErrors.MergeErrors(errors);
ValidateVariable(item.Result, compiler, dataObject, out errors);
allErrors.MergeErrors(errors);
IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", index.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.StringToConvert, "Convert", tmp, executionId), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem);
_debugInputs.Add(debugItem);
index++;
}
if (tmp != null)
{
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp);
while (itr.HasMoreRecords())
{
foreach (IBinaryDataListItem itm in itr.FetchNextRowData())
{
try
{
IBinaryDataListItem res = converter.TryConvert(item.ConvertType, itm);
string expression = item.Result;
// 27.08.2013
// NOTE : The result must remain [ as this is how the fliping studio generates the result when using (*) notation
// There is a proper bug in to fix this issue, but since the studio is spaghetti I will leave this to the experts ;)
// This is a tmp fix to the issue
if (expression == "[" || DataListUtil.GetRecordsetIndexType(expression) == enRecordsetIndexType.Star)
{
expression = DataListUtil.AddBracketsToValueIfNotExist(res.DisplayValue);
}
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
IsSingleValueRule rule = new IsSingleValueRule(() => expression);
var singleresError = rule.Check();
if (singleresError != null)
{
allErrors.AddError(singleresError.Message);
}
else
{
toUpsert.Add(expression, res.TheValue);
// Upsert the entire payload
}
allErrors.MergeErrors(errors);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
toUpsert.Add(item.Result, null);
}
}
}
compiler.Upsert(executionId, toUpsert, out errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem);
_debugOutputs.Add(debugItem);
}
toUpsert.DebugOutputs.Clear();
}
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCaseConvertActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
int outIndex = 1;
foreach (ICaseConvertTO item in ConvertCollection)
{
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.Result, "", tmp, executionId), debugItem);
_debugOutputs.Add(debugItem);
outIndex++;
}
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
/// <summary>
/// Executes the logic of the activity and calls the backend code to do the work
/// Also responsible for adding the results to the data list
/// </summary>
/// <param name="context"></param>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDev2ReplaceOperation replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false);
toUpsert.IsDebug = dataObject.IsDebugMode();
ErrorResultTO errors;
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
IDev2IteratorCollection iteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection();
IBinaryDataListEntry expressionsEntryFind = compiler.Evaluate(executionId, enActionType.User, Find, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator itrFind = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntryFind);
iteratorCollection.AddIterator(itrFind);
IBinaryDataListEntry expressionsEntryReplaceWith = compiler.Evaluate(executionId, enActionType.User, ReplaceWith, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator itrReplace = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntryReplaceWith);
iteratorCollection.AddIterator(itrReplace);
int replacementCount = 0;
int replacementTotal = 0;
InitializeDebug(dataObject);
try
{
IList <string> toSearch = FieldsToSearch.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in toSearch)
{
if (dataObject.IsDebugMode())
{
IBinaryDataListEntry inFieldsEntry = compiler.Evaluate(executionId, enActionType.User, s, false, out errors);
AddDebugInputItem(new DebugItemVariableParams(s, "In Field(s)", inFieldsEntry, executionId));
}
}
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
while (iteratorCollection.HasMoreData())
{
// now process each field for entire evaluated Where expression....
var findValue = iteratorCollection.FetchNextRow(itrFind).TheValue;
var replaceWithValue = iteratorCollection.FetchNextRow(itrReplace).TheValue;
foreach (string s in toSearch)
{
if (!DataListUtil.IsEvaluated(s))
{
allErrors.AddError("Please insert only variables into Fields To Search");
return;
}
if (!string.IsNullOrEmpty(findValue))
{
IBinaryDataListEntry entryToReplaceIn;
toUpsert = replaceOperation.Replace(executionId, s.Trim(), findValue, replaceWithValue, CaseMatch, toUpsert, out errors, out replacementCount, out entryToReplaceIn);
}
replacementTotal += replacementCount;
allErrors.MergeErrors(errors);
}
}
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugItemVariableParams(Find, "Find", expressionsEntryFind, executionId));
AddDebugInputItem(new DebugItemVariableParams(ReplaceWith, "Replace With", expressionsEntryReplaceWith, executionId));
}
toUpsert.Add(Result, replacementTotal.ToString(CultureInfo.InvariantCulture));
// now push the result to the server
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception ex)
{
Dev2Logger.Log.Error("DSFReplace", ex);
allErrors.AddError(ex.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfReplaceActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
var contentItr = new WarewolfIterator(dataObject.Environment.Eval(FileContents, update));
colItr.AddVariableToIterateOn(contentItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if (dataObject.IsDebugMode())
{
AddDebugInputItem(OutputPath, "Output Path", dataObject.Environment, update);
AddDebugInputItem(new DebugItemStaticDataParams(GetMethod(), "Method"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update);
}
AddDebugInputItem(FileContents, "File Contents", dataObject.Environment, update);
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
var writeType = GetCorrectWriteType();
Dev2PutRawOperationTO putTo = ActivityIOFactory.CreatePutRawOperationTO(writeType, TextUtils.ReplaceWorkflowNewLinesWithEnvironmentNewLines(colItr.FetchNextValue(contentItr)));
IActivityIOPath opath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint endPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(opath);
try
{
if (allErrors.HasErrors())
{
outputs[0].OutputStrings.Add(null);
}
else
{
string result = broker.PutRaw(endPoint, putTo);
outputs[0].OutputStrings.Add(result);
}
}
catch (Exception e)
{
outputs[0].OutputStrings.Add(null);
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
#pragma warning disable S1541 // Methods and properties should not be too complex
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
#pragma warning restore S1541 // Methods and properties should not be too complex
{
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
var expression = Expression ?? string.Empty;
var roundingDecimalPlaces = RoundingDecimalPlaces ?? string.Empty;
var decimalPlacesToShow = DecimalPlacesToShow ?? string.Empty;
AddDebugInputItems(dataObject, update, expression, roundingDecimalPlaces, decimalPlacesToShow);
var colItr = new WarewolfListIterator();
var expressionIterator = CreateDataListEvaluateIterator(expression, dataObject.Environment, update);
var roundingDecimalPlacesIterator = CreateDataListEvaluateIterator(roundingDecimalPlaces, dataObject.Environment, update);
var decimalPlacesToShowIterator = CreateDataListEvaluateIterator(decimalPlacesToShow, dataObject.Environment, update);
colItr.AddVariableToIterateOn(expressionIterator);
colItr.AddVariableToIterateOn(roundingDecimalPlacesIterator);
colItr.AddVariableToIterateOn(decimalPlacesToShowIterator);
// Loop data ;)
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
var counter = 1;
while (colItr.HasMoreData())
{
var tmpDecimalPlacesToShow = colItr.FetchNextValue(decimalPlacesToShowIterator);
var adjustDecimalPlaces = tmpDecimalPlacesToShow.IsRealNumber(out int decimalPlacesToShowValue);
if (!string.IsNullOrEmpty(tmpDecimalPlacesToShow) && !adjustDecimalPlaces)
{
throw new Exception(ErrorResource.DecimalsNotValid);
}
var tmpDecimalPlaces = colItr.FetchNextValue(roundingDecimalPlacesIterator);
var roundingDecimalPlacesValue = 0;
if (!string.IsNullOrEmpty(tmpDecimalPlaces) && !tmpDecimalPlaces.IsRealNumber(out roundingDecimalPlacesValue))
{
throw new Exception(ErrorResource.RoundingNotValid);
}
string result;
var binaryDataListItem = colItr.FetchNextValue(expressionIterator);
var val = binaryDataListItem;
{
var formatNumberTo = new FormatNumberTO(val, RoundingType, roundingDecimalPlacesValue, adjustDecimalPlaces, decimalPlacesToShowValue);
result = _numberFormatter.Format(formatNumberTo);
}
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
UpdateResultRegions(dataObject.Environment, result, update == 0 ? counter : update);
counter++;
}
}
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFNumberFormatActivity", e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfNumberFormatActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
// ReSharper restore RedundantOverridenMember
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
ErrorResultTO errors;
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
try
{
string rawRecsetName = RetrieveItemForEvaluation(enIntellisensePartType.RecordsetsOnly, SortField);
string sortField = RetrieveItemForEvaluation(enIntellisensePartType.RecordsetFields, SortField);
bool descOrder = String.IsNullOrEmpty(SelectedSort) || SelectedSort.Equals("Backwards");
// Travis.Frisinger : New Stuff....
if (!string.IsNullOrEmpty(rawRecsetName))
{
IBinaryDataList bdl = compiler.FetchBinaryDataList(executionId, out errors);
IBinaryDataListEntry rsData;
string error;
bdl.TryGetEntry(rawRecsetName, out rsData, out error);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(SortField, "Sort Field", rsData, executionId);
}
allErrors.AddError(error);
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => SortField);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
// Check for fields
if (rsData != null && rsData.HasField(sortField))
{
rsData.Sort(sortField, descOrder, out error);
errors.AddError(error);
// Push back against the datalist
compiler.PushBinaryDataList(executionId, bdl, out errors);
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode())
{
bdl.TryGetEntry(rawRecsetName, out rsData, out error);
//Added for Bug 9479
string tmpExpression = SortField;
if (tmpExpression.Contains("()."))
{
tmpExpression = tmpExpression.Replace("().", "(*).");
}
AddDebugOutputItem(new DebugItemVariableParams(tmpExpression, "", rsData, executionId));
}
}
}
else
{
allErrors.AddError("No recordset given");
}
}
finally
{
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfSortRecordsActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
// End Travis.Frisinger New Stuff
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
//Guid executionId = DataListExecutionID.Get(context);
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
var colItr = new WarewolfListIterator();
var iteratorPropertyDictionary = new Dictionary <string, IWarewolfIterator>();
foreach (var propertyInfo in GetType().GetProperties().Where(info => info.IsDefined(typeof(Inputs))))
{
var attributes = (Inputs[])propertyInfo.GetCustomAttributes(typeof(Inputs), false);
var variableValue = propertyInfo.GetValue(this) as string;
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(variableValue, attributes[0].UserVisibleName, dataObject.Environment, update));
}
var dtItr = CreateDataListEvaluateIterator(variableValue, dataObject.Environment, update);
colItr.AddVariableToIterateOn(dtItr);
iteratorPropertyDictionary.Add(propertyInfo.Name, dtItr);
}
while (colItr.HasMoreData())
{
var evaluatedValues = new Dictionary <string, string>();
foreach (var dev2DataListEvaluateIterator in iteratorPropertyDictionary)
{
var binaryDataListItem = colItr.FetchNextValue(dev2DataListEvaluateIterator.Value);
evaluatedValues.Add(dev2DataListEvaluateIterator.Key, binaryDataListItem);
}
var result = PerformExecution(evaluatedValues);
dataObject.Environment.Assign(Result, result, update);
}
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
allErrors.MergeErrors(errors);
}
catch (Exception ex)
{
Dev2Logger.Log.Error(string.Format("{0} Exception", DisplayName), ex);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError(DisplayName, allErrors);
var errorList = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorList);
dataObject.Environment.Assign(Result, null, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override IList <OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
allErrors = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var outputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update));
colItr.AddVariableToIterateOn(outputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
colItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update));
colItr.AddVariableToIterateOn(privateKeyItr);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(OutputPath, "File or Folder", dataObject.Environment, update));
AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite"));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Destination Private Key File", dataObject.Environment, update);
}
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
Dev2CRUDOperationTO opTo = new Dev2CRUDOperationTO(Overwrite);
try
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(outputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Create(dstEndPoint, opTo, true);
outputs.Add(DataListFactory.CreateOutputTO(Result, result));
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
protected override IList <OutputTO> ExecuteConcreteAction(NativeActivityContext context, out ErrorResultTO allErrors)
{
IList <OutputTO> outputs = new List <OutputTO>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
allErrors = new ErrorResultTO();
ErrorResultTO errors;
Guid executionId = dataObject.DataListID;
IDev2IteratorCollection colItr = Dev2ValueObjectFactory.CreateIteratorCollection();
//get all the possible paths for all the string variables
IBinaryDataListEntry outputPathEntry = compiler.Evaluate(executionId, enActionType.User, OutputPath, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator outputItr = Dev2ValueObjectFactory.CreateEvaluateIterator(outputPathEntry);
colItr.AddIterator(outputItr);
IBinaryDataListEntry usernameEntry = compiler.Evaluate(executionId, enActionType.User, Username, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator unameItr = Dev2ValueObjectFactory.CreateEvaluateIterator(usernameEntry);
colItr.AddIterator(unameItr);
IBinaryDataListEntry passwordEntry = compiler.Evaluate(executionId, enActionType.User, Password, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator passItr = Dev2ValueObjectFactory.CreateEvaluateIterator(passwordEntry);
colItr.AddIterator(passItr);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugItemVariableParams(OutputPath, "File or Folder", outputPathEntry, executionId));
AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite"));
AddDebugInputItemUserNamePassword(executionId, usernameEntry);
}
while (colItr.HasMoreData())
{
IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker();
Dev2CRUDOperationTO opTo = new Dev2CRUDOperationTO(Overwrite);
try
{
IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextRow(outputItr).TheValue,
colItr.FetchNextRow(unameItr).TheValue,
colItr.FetchNextRow(passItr).TheValue,
true);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Create(dstEndPoint, opTo, true);
outputs.Add(DataListFactory.CreateOutputTO(Result, result));
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, (string)null));
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
/// <summary>
/// Invokes the workflow impl.
/// </summary>
/// <param name="workflowActivity">The workflow activity.</param>
/// <param name="dataTransferObject">The data transfer object.</param>
/// <param name="executionExtensions">The execution extensions.</param>
/// <param name="instanceId">The instance id.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="bookmarkName">Name of the bookmark.</param>
/// <param name="isDebug">if set to <c>true</c> [is debug].</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
private IDSFDataObject InvokeWorkflowImpl(Activity workflowActivity, IDSFDataObject dataTransferObject, IList <object> executionExtensions, Guid instanceId, IWorkspace workspace, string bookmarkName, bool isDebug, out ErrorResultTO errors)
{
Tracker.TrackEvent(TrackerEventGroup.Workflows, TrackerEventName.Executed, string.Format("RES-{0}", dataTransferObject.ResourceID));
if (AllErrors == null)
{
AllErrors = new ErrorResultTO();
}
IExecutionToken exeToken = new ExecutionToken {
IsUserCanceled = false
};
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.StartedCallback);
WorkflowApplication wfApp = InitEntryPoint(workflowActivity, dataTransferObject, executionExtensions, instanceId, workspace, bookmarkName);
errors = new ErrorResultTO();
if (wfApp != null)
{
// add termination token
wfApp.Extensions.Add(exeToken);
using (ManualResetEventSlim waitHandle = new ManualResetEventSlim(false))
{
WorkflowApplicationRun run = new WorkflowApplicationRun(this, waitHandle, dataTransferObject, wfApp, workspace, executionExtensions, FetchParentInstanceId(dataTransferObject), isDebug, errors, exeToken);
if (instanceId == Guid.Empty)
{
Interlocked.Increment(ref Balance);
run.Run();
_runTime = DateTime.Now;
waitHandle.Wait();
}
else
{
Interlocked.Increment(ref Balance);
try
{
if (!string.IsNullOrEmpty(bookmarkName))
{
dataTransferObject.CurrentBookmarkName = bookmarkName;
run.Resume(dataTransferObject);
}
else
{
run.Run();
_runTime = DateTime.Now;
}
waitHandle.Wait();
}
catch (InstanceNotReadyException e1)
{
Interlocked.Decrement(ref Balance);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
errors.AddError(e1.Message);
AllErrors.AddError(e1.Message);
return(null);
}
catch (InstancePersistenceException e2)
{
Interlocked.Decrement(ref Balance);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
errors.AddError(e2.Message);
AllErrors.AddError(e2.Message);
return(run.DataTransferObject.Clone());
}
catch (Exception ex)
{
Interlocked.Decrement(ref Balance);
errors.AddError(ex.Message);
AllErrors.AddError(ex.Message);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
return(run.DataTransferObject.Clone());
}
}
Interlocked.Decrement(ref Balance);
dataTransferObject = run.DataTransferObject.Clone();
var wfappUtils = new WfApplicationUtils();
ErrorResultTO invokeErrors;
if (dataTransferObject.IsDebugMode())
{
wfappUtils.DispatchDebugState(dataTransferObject, StateType.End, AllErrors.HasErrors(), AllErrors.MakeDisplayReady(), out invokeErrors, _runTime, false, true);
}
//AllErrors.MergeErrors(invokeErrors);
// avoid memory leak ;)
run.Dispose();
}
}
else
{
errors.AddError("Internal System Error : Could not create workflow execution wrapper");
}
return(dataTransferObject);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_dataObject = dataObject;
ErrorResultTO allErrors = new ErrorResultTO();
int indexToUpsertTo = 0;
InitializeDebug(dataObject);
try
{
IExchange runtimeSource = ResourceCatalog.GetResource <ExchangeSource>(dataObject.WorkspaceID, SavedSource.ResourceID);
if (runtimeSource == null)
{
dataObject.Environment.Errors.Add(ErrorResource.InvalidEmailSource);
return;
}
if (IsDebug)
{
AddDebugInputItem(new DebugEvalResult(To, "To", dataObject.Environment, update));
AddDebugInputItem(new DebugEvalResult(Subject, "Subject", dataObject.Environment, update));
AddDebugInputItem(new DebugEvalResult(Body, "Body", dataObject.Environment, update));
}
var colItr = new WarewolfListIterator();
var toItr = new WarewolfIterator(dataObject.Environment.Eval(To, update));
colItr.AddVariableToIterateOn(toItr);
var ccItr = new WarewolfIterator(dataObject.Environment.Eval(Cc, update));
colItr.AddVariableToIterateOn(ccItr);
var bccItr = new WarewolfIterator(dataObject.Environment.Eval(Bcc, update));
colItr.AddVariableToIterateOn(bccItr);
var subjectItr = new WarewolfIterator(dataObject.Environment.Eval(Subject, update));
colItr.AddVariableToIterateOn(subjectItr);
var bodyItr = new WarewolfIterator(dataObject.Environment.Eval(Body, update));
colItr.AddVariableToIterateOn(bodyItr);
var attachmentsItr = new WarewolfIterator(dataObject.Environment.Eval(Attachments ?? string.Empty, update));
colItr.AddVariableToIterateOn(attachmentsItr);
if (!allErrors.HasErrors())
{
while (colItr.HasMoreData())
{
ErrorResultTO errors;
var result = _emailSender.SendEmail(runtimeSource, colItr, toItr, ccItr, bccItr, subjectItr, bodyItr, attachmentsItr, out errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
indexToUpsertTo = UpsertResult(indexToUpsertTo, dataObject.Environment, result, update);
}
}
if (IsDebug && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
}
else
{
if (IsDebug)
{
AddDebugInputItem(To, "To");
AddDebugInputItem(Subject, "Subject");
AddDebugInputItem(Body, "Body");
}
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFEmail", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
if (allErrors.HasErrors())
{
foreach (var err in allErrors.FetchErrors())
{
dataObject.Environment.Errors.Add(err);
}
UpsertResult(indexToUpsertTo, dataObject.Environment, null, update);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfSendEmailActivity", allErrors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
void DoInsertForSqlServer(DbSource runtimeDatabase, SqlBulkCopyOptions currentOptions, IDSFDataObject dataObject, ErrorResultTO allErrors, IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, ref ErrorResultTO errorResultTo, ref bool addExceptionToErrorList, int update)
{
SqlBulkCopy sqlBulkCopy;
if (String.IsNullOrEmpty(BatchSize) && String.IsNullOrEmpty(Timeout))
{
sqlBulkCopy = new SqlBulkCopy(runtimeDatabase.ConnectionString, currentOptions)
{
DestinationTableName = TableName
};
}
else
{
sqlBulkCopy = SetupSqlBulkCopy(batchItr, parametersIteratorCollection, timeoutItr, runtimeDatabase, currentOptions);
}
if (sqlBulkCopy != null)
{
var dataTableToInsert = BuildDataTableToInsert();
var types = GETTypesFromMappingTypes();
var columns = GetNamesFromMappings();
if (InputMappings != null && InputMappings.Count > 0)
{
var iteratorCollection = new WarewolfListIterator();
var listOfIterators = GetIteratorsFromInputMappings(dataObject, iteratorCollection, out errorResultTo, update);
iteratorCollection.Types = types;
iteratorCollection.Names = columns;
allErrors.MergeErrors(errorResultTo);
FillDataTableWithDataFromDataList(iteratorCollection, dataTableToInsert, listOfIterators);
// oh no, we have an issue, bubble it out ;)
if (allErrors.HasErrors())
{
addExceptionToErrorList = false;
throw new Exception("Problems with Iterators for SQLBulkInsert");
}
// emit options to debug as per acceptance test ;)
if (dataObject.IsDebugMode())
{
AddBatchSizeAndTimeOutToDebug(dataObject.Environment, update);
AddOptionsDebugItems();
}
if (InputMappings != null)
{
foreach (var dataColumnMapping in InputMappings)
{
if (!String.IsNullOrEmpty(dataColumnMapping.InputColumn))
{
sqlBulkCopy.ColumnMappings.Add(new SqlBulkCopyColumnMapping(dataColumnMapping.OutputColumn.ColumnName, dataColumnMapping.OutputColumn.ColumnName));
}
}
}
var wrapper = new SqlBulkCopyWrapper(sqlBulkCopy);
SqlBulkInserter.Insert(wrapper, dataTableToInsert);
dataObject.Environment.Assign(Result, "Success", update);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult("Success", Result, ""));
}
}
if (dataTableToInsert != null)
{
dataTableToInsert.Dispose();
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
ValidateRecordsetName(RecordsetName, errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
try
{
string rs = DataListUtil.ExtractRecordsetNameFromValue(RecordsetName);
if (CountNumber == string.Empty)
{
allErrors.AddError("Blank result variable");
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(dataObject.Environment.ToStar(RecordsetName), "Recordset", dataObject.Environment, update));
}
var rule = new IsSingleValueRule(() => CountNumber);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
var count = 0;
if (dataObject.Environment.HasRecordSet(RecordsetName))
{
count = dataObject.Environment.GetCount(rs);
}
var value = count.ToString();
dataObject.Environment.Assign(CountNumber, value, update);
AddDebugOutputItem(new DebugEvalResult(CountNumber, "", dataObject.Environment, update));
}
}
catch (Exception e)
{
AddDebugInputItem(new DebugItemStaticDataParams("", RecordsetName, "Recordset", "="));
allErrors.AddError(e.Message);
dataObject.Environment.Assign(CountNumber, "0", update);
AddDebugOutputItem(new DebugItemStaticDataParams("0", CountNumber, "", "="));
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCountRecordsActivity", allErrors);
var errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update)
{
IList<OutputTO> outputs = new List<OutputTO>();
allErrors = new ErrorResultTO();
ColItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update));
ColItr.AddVariableToIterateOn(inputItr);
var outputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update));
ColItr.AddVariableToIterateOn(outputItr);
var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update));
ColItr.AddVariableToIterateOn(unameItr);
var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update));
ColItr.AddVariableToIterateOn(passItr);
var desunameItr = new WarewolfIterator(dataObject.Environment.Eval(DestinationUsername, update));
ColItr.AddVariableToIterateOn(desunameItr);
var despassItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedDestinationPassword,update));
ColItr.AddVariableToIterateOn(despassItr);
AddItemsToIterator(dataObject.Environment, update);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if(dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(InputPath, "Source Path", dataObject.Environment, update));
AddDebugInputItemUserNamePassword(dataObject.Environment, update);
AddDebugInputItem(new DebugEvalResult(OutputPath, "Destination Path", dataObject.Environment, update));
AddDebugInputItemDestinationUsernamePassword(dataObject.Environment, DestinationPassword, DestinationUsername, update);
AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite"));
AddDebugInputItems(dataObject.Environment, update);
}
while(ColItr.HasMoreData())
{
var hasError = false;
IActivityIOPath src = null;
IActivityIOPath dst = null;
try
{
src = ActivityIOFactory.CreatePathFromString(ColItr.FetchNextValue(inputItr),
ColItr.FetchNextValue(unameItr),
ColItr.FetchNextValue(passItr),
true);
}
catch(IOException ioException)
{
allErrors.AddError("Source: " + ioException.Message);
hasError = true;
}
try
{
dst = ActivityIOFactory.CreatePathFromString(ColItr.FetchNextValue(outputItr),
ColItr.FetchNextValue(desunameItr),
ColItr.FetchNextValue(despassItr),
true);
}
catch(IOException ioException)
{
allErrors.AddError("Destination:" + ioException.Message);
hasError = true;
}
if(hasError)
{
outputs[0].OutputStrings.Add(null);
MoveRemainingIterators();
continue;
}
IActivityIOOperationsEndPoint scrEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(src);
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
try
{
IActivityOperationsBroker broker = GetOperationBroker();
var result = ExecuteBroker(broker, scrEndPoint, dstEndPoint);
outputs[0].OutputStrings.Add(result);
}
catch(Exception e)
{
allErrors.AddError(e.Message);
outputs[0].OutputStrings.Add(null);
}
}
return outputs;
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugOutputs.Clear();
_isDebugMode = dataObject.IsDebugMode();
ErrorResultTO errors = new ErrorResultTO();
ErrorResultTO allErrors = new ErrorResultTO();
XPathParser parser = new XPathParser();
int i = 0;
InitializeDebug(dataObject);
try
{
if (!errors.HasErrors())
{
if (_isDebugMode)
{
AddSourceStringDebugInputItem(SourceString, dataObject.Environment);
AddResultDebugInputs(ResultsCollection, out errors);
allErrors.MergeErrors(errors);
}
if (!allErrors.HasErrors())
{
var itr = new WarewolfListIterator();
var sourceIterator = new WarewolfIterator(dataObject.Environment.Eval(SourceString));
itr.AddVariableToIterateOn(sourceIterator);
while (itr.HasMoreData())
{
var c = itr.FetchNextValue(sourceIterator);
//foreach(IBinaryDataListItem c in cols)
{
for (i = 0; i < ResultsCollection.Count; i++)
{
if (!string.IsNullOrEmpty(ResultsCollection[i].OutputVariable))
{
var xpathEntry = dataObject.Environment.Eval(ResultsCollection[i].XPath);
var xpathIterator = new WarewolfIterator(xpathEntry);
while (xpathIterator.HasMoreData())
{
var xpathCol = xpathIterator.GetNextValue();
//foreach(IBinaryDataListItem xPathCol in xpathCols)
{
try
{
List <string> eval = parser.ExecuteXPath(c, xpathCol).ToList();
//2013.06.03: Ashley Lewis for bug 9498 - handle line breaks in multi assign
string[] openParts = Regex.Split(ResultsCollection[i].OutputVariable, @"\[\[");
string[] closeParts = Regex.Split(ResultsCollection[i].OutputVariable, @"\]\]");
if (openParts.Count() == closeParts.Count() && openParts.Count() > 2 && closeParts.Count() > 2)
{
foreach (var newFieldName in openParts)
{
if (!string.IsNullOrEmpty(newFieldName))
{
string cleanFieldName;
if (newFieldName.IndexOf("]]", StringComparison.Ordinal) + 2 < newFieldName.Length)
{
cleanFieldName = "[[" + newFieldName.Remove(newFieldName.IndexOf("]]", StringComparison.Ordinal) + 2);
}
else
{
cleanFieldName = "[[" + newFieldName;
}
AssignResult(cleanFieldName, dataObject, eval);
}
}
}
else
{
var variable = ResultsCollection[i].OutputVariable;
AssignResult(variable, dataObject, eval);
}
}
catch (Exception e)
{
allErrors.AddError(e.Message);
dataObject.Environment.Assign(ResultsCollection[i].OutputVariable, null);
}
}
}
}
}
}
allErrors.MergeErrors(errors);
}
}
if (_isDebugMode && !allErrors.HasErrors())
{
var innerCount = 1;
foreach (var debugOutputTo in ResultsCollection)
{
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugEvalResult(DataListUtil.ReplaceRecordsetBlankWithStar(debugOutputTo.OutputVariable), "", dataObject.Environment), itemToAdd);
_debugOutputs.Add(itemToAdd);
innerCount++;
}
}
}
}
catch (Exception ex)
{
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var actualIndex = i - 1;
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfXPathActivity", allErrors);
var errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
if (actualIndex > -1)
{
dataObject.Environment.Assign(ResultsCollection[actualIndex].OutputVariable, null);
}
}
if (_isDebugMode)
{
if (hasErrors)
{
if (_isDebugMode)
{
var itemToAdd = new DebugItem();
if (actualIndex < 0)
{
actualIndex = 0;
}
AddDebugItem(new DebugItemStaticDataParams("", (actualIndex + 1).ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugEvalResult(ResultsCollection[actualIndex].OutputVariable, "", dataObject.Environment), itemToAdd);
_debugOutputs.Add(itemToAdd);
}
}
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
private ErrorResultTO UpdateEnvironment(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, IExecutionEnvironment env, ErrorResultTO errors)
{
if (dataObject.IsDebugMode())
{
AddDebugInputItem(Length, From, To, dataObject.Environment, RandomType, update);
}
var lengthItr = !String.IsNullOrEmpty(Length) ? new WarewolfIterator(env.EvalStrict(Length, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataStorage.WarewolfAtom.Nothing, });
var fromItr = !String.IsNullOrEmpty(From) ? new WarewolfIterator(env.EvalStrict(From, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataStorage.WarewolfAtom.Nothing, });
var toItr = !String.IsNullOrEmpty(To) ? new WarewolfIterator(env.EvalStrict(To, update)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataStorage.WarewolfAtom.Nothing, });
var colItr = new WarewolfListIterator();
colItr.AddVariableToIterateOn(lengthItr);
colItr.AddVariableToIterateOn(fromItr);
colItr.AddVariableToIterateOn(toItr);
var dev2Random = new Dev2Random();
var counter = 1;
while (colItr.HasMoreData())
{
var lengthNum = -1;
var fromNum = -1.0;
var toNum = -1.0;
var fromValue = colItr.FetchNextValue(fromItr);
var toValue = colItr.FetchNextValue(toItr);
var lengthValue = colItr.FetchNextValue(lengthItr);
if (RandomType == enRandomType.Numbers)
{
#region Getting the From
fromNum = GetFromValue(fromValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
#region Getting the To
toNum = GetToValue(toValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
if (RandomType != enRandomType.Numbers && RandomType != enRandomType.Guid)
{
#region Getting the Length
lengthNum = GetLengthValue(lengthValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
var value = dev2Random.GetRandom(RandomType, lengthNum, fromNum, toNum);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
env.Assign(Result, value, update == 0 ? counter : update);
}
counter++;
}
return(errors);
}
void DoInsertForMySql(DbSource runtimeDatabase, SqlBulkCopyOptions currentOptions, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator batchItr, IWarewolfIterator timeoutItr, IDSFDataObject dataObject, ErrorResultTO errorResultTo, ErrorResultTO allErrors, ref bool addExceptionToErrorList, int update)
{
var sqlBulkCopy = new MySqlBulkLoader(new MySqlConnection(runtimeDatabase.ConnectionString));
TableName = TableName.Replace("[", "").Replace("]", "");
if (TableName.Contains("."))
{
TableName = TableName.Substring(TableName.IndexOf(".", StringComparison.Ordinal) + 1);
}
if (string.IsNullOrEmpty(BatchSize) && string.IsNullOrEmpty(Timeout))
{
sqlBulkCopy = new MySqlBulkLoader(new MySqlConnection(runtimeDatabase.ConnectionString))
{
TableName = TableName, FieldTerminator = ",", LineTerminator = "\n"
};
}
else
{
while (parametersIteratorCollection.HasMoreData())
{
sqlBulkCopy = SetupMySqlBulkCopy(batchItr, parametersIteratorCollection, timeoutItr, runtimeDatabase, currentOptions);
}
}
if (sqlBulkCopy != null)
{
var dataTableToInsert = BuildDataTableToInsertMySql();
if (InputMappings != null && InputMappings.Count > 0)
{
var iteratorCollection = new WarewolfListIterator();
var listOfIterators = GetIteratorsFromInputMappings(dataObject, iteratorCollection, out errorResultTo, update);
allErrors.MergeErrors(errorResultTo);
// oh no, we have an issue, bubble it out ;)
if (allErrors.HasErrors())
{
addExceptionToErrorList = false;
throw new Exception(string.Format(ErrorResource.ProblemsWithIterators, "SQLBulkInsert"));
}
// emit options to debug as per acceptance test ;)
if (dataObject.IsDebugMode())
{
AddBatchSizeAndTimeOutToDebug(dataObject.Environment, update);
AddOptionsDebugItems();
}
FillDataTableWithDataFromDataList(iteratorCollection, dataTableToInsert, listOfIterators);
sqlBulkCopy = AddInputMappings(sqlBulkCopy);
}
// Pass in wrapper now ;)
var wrapper = new MySqlBulkCopyWrapper(sqlBulkCopy);
var inserted = SqlBulkInserter.Insert(wrapper, dataTableToInsert);
var resultString = inserted ? "Success" : "Failure";
dataObject.Environment.Assign(Result, resultString, update);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult(resultString, Result, ""));
}
allErrors.MergeErrors(errorResultTo);
dataTableToInsert?.Dispose();
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDev2ReplaceOperation replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
ErrorResultTO errors;
ErrorResultTO allErrors = new ErrorResultTO();
int replacementCount = 0;
int replacementTotal = 0;
InitializeDebug(dataObject);
try
{
IList <string> toSearch = FieldsToSearch.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in toSearch)
{
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(s, "In Field(s)", dataObject.Environment));
if (Find != null)
{
AddDebugInputItem(new DebugEvalResult(Find, "Find", dataObject.Environment));
}
if (ReplaceWith != null)
{
AddDebugInputItem(new DebugEvalResult(ReplaceWith, "Replace With", dataObject.Environment));
}
}
}
IWarewolfListIterator iteratorCollection = new WarewolfListIterator();
var finRes = dataObject.Environment.Eval(Find);
if (ExecutionEnvironment.IsNothing(finRes))
{
if (!string.IsNullOrEmpty(Result))
{
dataObject.Environment.Assign(Result, replacementTotal.ToString(CultureInfo.InvariantCulture));
}
}
else
{
var itrFind = new WarewolfIterator(dataObject.Environment.Eval(Find));
iteratorCollection.AddVariableToIterateOn(itrFind);
var itrReplace = new WarewolfIterator(dataObject.Environment.Eval(ReplaceWith));
iteratorCollection.AddVariableToIterateOn(itrReplace);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
while (iteratorCollection.HasMoreData())
{
// now process each field for entire evaluated Where expression....
var findValue = iteratorCollection.FetchNextValue(itrFind);
var replaceWithValue = iteratorCollection.FetchNextValue(itrReplace);
foreach (string s in toSearch)
{
if (!DataListUtil.IsEvaluated(s))
{
allErrors.AddError("Please insert only variables into Fields To Search");
return;
}
if (!string.IsNullOrEmpty(findValue))
{
dataObject.Environment.ApplyUpdate(s, a => DataASTMutable.WarewolfAtom.NewDataString(replaceOperation.Replace(a.ToString(), findValue, replaceWithValue, CaseMatch, out errors, ref replacementCount)));
}
replacementTotal += replacementCount;
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(Result))
{
if (replacementCount > 0)
{
AddDebugOutputItem(new DebugEvalResult(s, "", dataObject.Environment));
}
}
}
}
}
}
if (!string.IsNullOrEmpty(Result))
{
dataObject.Environment.Assign(Result, replacementTotal.ToString(CultureInfo.InvariantCulture));
}
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
// now push the result to the server
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception ex)
{
Dev2Logger.Log.Error("DSFReplace", ex);
allErrors.AddError(ex.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfReplaceActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(Result, null);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
if (dataObject.IsDebugMode())
{
if (string.IsNullOrEmpty(Input1))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(CultureInfo.CurrentCulture), "now()", "Input 1", "="));
}
else
{
AddDebugInputItem(Input1, "Input 1", dataObject.Environment);
}
if (string.IsNullOrEmpty(Input2))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(CultureInfo.CurrentCulture), "now()", "Input 2", "="));
}
else
{
AddDebugInputItem(Input2, "Input 2", dataObject.Environment);
}
AddDebugInputItem(InputFormat, "Input Format", dataObject.Environment);
if (!String.IsNullOrEmpty(OutputType))
{
AddDebugInputItem(new DebugItemStaticDataParams(OutputType, "Output In"));
}
}
var colItr = new WarewolfListIterator();
var input1Itr = new WarewolfIterator(dataObject.Environment.EvalStrict(string.IsNullOrEmpty(Input1) ? GlobalConstants.CalcExpressionNow : Input1));
colItr.AddVariableToIterateOn(input1Itr);
var evalInp2 = dataObject.Environment.EvalStrict(string.IsNullOrEmpty(Input2) ? GlobalConstants.CalcExpressionNow : Input2);
var input2Itr = new WarewolfIterator(evalInp2);
colItr.AddVariableToIterateOn(input2Itr);
var ifItr = new WarewolfIterator(dataObject.Environment.Eval(InputFormat ?? string.Empty));
colItr.AddVariableToIterateOn(ifItr);
int indexToUpsertTo = 1;
while (colItr.HasMoreData())
{
IDateTimeDiffTO transObj = ConvertToDateTimeDiffTo(colItr.FetchNextValue(input1Itr),
colItr.FetchNextValue(input2Itr),
colItr.FetchNextValue(ifItr),
OutputType);
//Create a DateTimeComparer using the DateTimeConverterFactory
IDateTimeComparer comparer = DateTimeConverterFactory.CreateComparer();
//Call the TryComparer method on the DateTimeComparer and pass it the IDateTimeDiffTO created from the ConvertToDateTimeDiffTO Method
string result;
string error;
string expression = Result;
if (comparer.TryCompare(transObj, out result, out error))
{
if (DataListUtil.IsValueRecordset(Result) &&
DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
expression = Result.Replace(GlobalConstants.StarExpression, indexToUpsertTo.ToString(CultureInfo.InvariantCulture));
}
else
{
expression = Result;
}
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
dataObject.Environment.Assign(expression, result);
}
}
else
{
DoDebugOutput(dataObject, expression);
allErrors.AddError(error);
}
indexToUpsertTo++;
}
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, null, dataObject.Environment));
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFDateTime", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfDateTimeDifferenceActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(Result, null);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
IDev2MergeOperations mergeOperations = new Dev2MergeOperations();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errorResultTo = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
CleanArguments(MergeCollection);
if (MergeCollection.Count <= 0)
{
return;
}
IWarewolfListIterator warewolfListIterator = new WarewolfListIterator();
allErrors.MergeErrors(errorResultTo);
Dictionary <int, List <IWarewolfIterator> > listOfIterators = new Dictionary <int, List <IWarewolfIterator> >();
#region Create a iterator for each row in the data grid in the designer so that the right iteration happen on the data
int dictionaryKey = 0;
foreach (DataMergeDTO row in MergeCollection)
{
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", (MergeCollection.IndexOf(row) + 1).ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(row.InputVariable, "", dataObject.Environment, update, true), debugItem);
AddDebugItem(new DebugItemStaticDataParams(row.MergeType, "With"), debugItem);
AddDebugItem(new DebugEvalResult(row.At, "Using", dataObject.Environment, update), debugItem);
AddDebugItem(new DebugEvalResult(row.Padding, "Pad", dataObject.Environment, update), debugItem);
//Old workflows don't have this set.
if (row.Alignment == null)
{
row.Alignment = string.Empty;
}
AddDebugItem(DataListUtil.IsEvaluated(row.Alignment) ? new DebugItemStaticDataParams("", row.Alignment, "Align") : new DebugItemStaticDataParams(row.Alignment, "Align"), debugItem);
_debugInputs.Add(debugItem);
}
var listOfEvalResultsForInput = dataObject.Environment.EvalForDataMerge(row.InputVariable, update);
var innerIterator = new WarewolfListIterator();
var innerListOfIters = new List <WarewolfIterator>();
foreach (var listOfIterator in listOfEvalResultsForInput)
{
var inIterator = new WarewolfIterator(listOfIterator);
innerIterator.AddVariableToIterateOn(inIterator);
innerListOfIters.Add(inIterator);
}
var atomList = new List <DataStorage.WarewolfAtom>();
while (innerIterator.HasMoreData())
{
var stringToUse = "";
foreach (var warewolfIterator in innerListOfIters)
{
stringToUse += warewolfIterator.GetNextValue();
}
atomList.Add(DataStorage.WarewolfAtom.NewDataString(stringToUse));
}
var finalString = string.Join("", atomList);
var inputListResult = CommonFunctions.WarewolfEvalResult.NewWarewolfAtomListresult(new WarewolfAtomList <DataStorage.WarewolfAtom>(DataStorage.WarewolfAtom.Nothing, atomList));
if (DataListUtil.IsFullyEvaluated(finalString))
{
inputListResult = dataObject.Environment.Eval(finalString, update);
}
var inputIterator = new WarewolfIterator(inputListResult);
var atIterator = new WarewolfIterator(dataObject.Environment.Eval(row.At, update));
var paddingIterator = new WarewolfIterator(dataObject.Environment.Eval(row.Padding, update));
warewolfListIterator.AddVariableToIterateOn(inputIterator);
warewolfListIterator.AddVariableToIterateOn(atIterator);
warewolfListIterator.AddVariableToIterateOn(paddingIterator);
listOfIterators.Add(dictionaryKey, new List <IWarewolfIterator> {
inputIterator, atIterator, paddingIterator
});
dictionaryKey++;
}
#endregion
#region Iterate and Merge Data
if (!allErrors.HasErrors())
{
while (warewolfListIterator.HasMoreData())
{
int pos = 0;
foreach (var iterator in listOfIterators)
{
var val = warewolfListIterator.FetchNextValue(iterator.Value[0]);
var at = warewolfListIterator.FetchNextValue(iterator.Value[1]);
var pad = warewolfListIterator.FetchNextValue(iterator.Value[2]);
if (val != null)
{
if (at != null)
{
if (pad != null)
{
if (MergeCollection[pos].MergeType == "Index")
{
if (string.IsNullOrEmpty(at))
{
allErrors.AddError(ErrorResource.BlankUSINGValue);
}
int atValue;
if (!Int32.TryParse(at, out atValue) || atValue < 0)
{
allErrors.AddError(ErrorResource.USINGMustBeARealNumber);
}
if (pad.Length > 1)
{
allErrors.AddError(ErrorResource.PADDINGMustBeSingleCharecter);
}
}
else
{
if (MergeCollection[pos].MergeType == "Chars" && string.IsNullOrEmpty(at))
{
allErrors.AddError(ErrorResource.BlankUSINGValue);
}
}
mergeOperations.Merge(val, MergeCollection[pos].MergeType, at, pad, MergeCollection[pos].Alignment);
pos++;
}
}
}
}
}
if (!allErrors.HasErrors())
{
if (string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugItemStaticDataParams("", ""));
}
else
{
dataObject.Environment.Assign(Result, mergeOperations.MergeData.ToString(), update);
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
}
}
#endregion Iterate and Merge Data
}
catch (Exception e)
{
Dev2Logger.Error("DSFDataMerge", e);
allErrors.AddError(e.Message);
}
finally
{
#region Handle Errors
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfDataMergeActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
#endregion
}
}
public void DispatchDebugState(IDSFDataObject dataObject, StateType stateType, bool hasErrors, string existingErrors, out ErrorResultTO errors, DateTime? workflowStartTime = null, bool interrogateInputs = false, bool interrogateOutputs = false)
{
errors = new ErrorResultTO();
if(dataObject != null)
{
Guid parentInstanceId;
Guid.TryParse(dataObject.ParentInstanceID, out parentInstanceId);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
bool hasError = dataObject.Environment.HasErrors();
var errorMessage = String.Empty;
if(hasError)
{
errorMessage = dataObject.Environment.FetchErrors();
}
if(String.IsNullOrEmpty(existingErrors))
{
existingErrors = errorMessage;
}
else
{
existingErrors += Environment.NewLine + errorMessage;
}
var debugState = new DebugState
{
ID = dataObject.OriginalInstanceID,
ParentID = parentInstanceId,
WorkspaceID = dataObject.WorkspaceID,
StateType = stateType,
StartTime = workflowStartTime ?? DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
DisplayName = dataObject.ServiceName,
IsSimulation = dataObject.IsOnDemandSimulation,
ServerID = dataObject.ServerID,
OriginatingResourceID = dataObject.ResourceID,
OriginalInstanceID = dataObject.OriginalInstanceID,
Server = string.Empty,
Version = string.Empty,
SessionID = dataObject.DebugSessionID,
EnvironmentID = dataObject.EnvironmentID,
ClientID = dataObject.ClientID,
Name = stateType.ToString(),
HasError = hasErrors || hasError,
ErrorMessage = existingErrors
};
if(interrogateInputs)
{
ErrorResultTO invokeErrors;
var defs = compiler.GenerateDefsFromDataListForDebug(FindServiceShape(dataObject.WorkspaceID, dataObject.ResourceID), enDev2ColumnArgumentDirection.Input);
var inputs = GetDebugValues(defs, dataObject, out invokeErrors);
errors.MergeErrors(invokeErrors);
debugState.Inputs.AddRange(inputs);
}
if(interrogateOutputs)
{
ErrorResultTO invokeErrors;
var defs = compiler.GenerateDefsFromDataListForDebug(FindServiceShape(dataObject.WorkspaceID, dataObject.ResourceID), enDev2ColumnArgumentDirection.Output);
var inputs = GetDebugValues(defs, dataObject, out invokeErrors);
errors.MergeErrors(invokeErrors);
debugState.Outputs.AddRange(inputs);
}
if(stateType == StateType.End)
{
debugState.NumberOfSteps = dataObject.NumberOfSteps;
}
if(stateType == StateType.Start)
{
debugState.ExecutionOrigin = dataObject.ExecutionOrigin;
debugState.ExecutionOriginDescription = dataObject.ExecutionOriginDescription;
}
if(dataObject.IsDebugMode() || (dataObject.RunWorkflowAsync && !dataObject.IsFromWebServer))
{
var debugDispatcher = GetDebugDispatcher();
if(debugState.StateType == StateType.End)
{
while(!debugDispatcher.IsQueueEmpty)
{
Thread.Sleep(100);
}
debugDispatcher.Write(debugState, dataObject.RemoteInvoke, dataObject.RemoteInvokerID, dataObject.ParentInstanceID, dataObject.RemoteDebugItems);
}
else
{
debugDispatcher.Write(debugState);
}
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
var errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
try
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(dataObject.Environment, update);
}
var input = string.IsNullOrEmpty(Expression) ? Expression : Expression.Replace("\\r", string.Empty).Replace("\\n", string.Empty).Replace(Environment.NewLine, "");
var warewolfListIterator = new WarewolfListIterator();
var calc = String.Format(GlobalConstants.CalculateTextConvertFormat, input);
var warewolfEvalResult = dataObject.Environment.Eval(calc, update);
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult scalarResult && scalarResult.Item.IsNothing)
{
throw new NullValueInVariableException(ErrorResource.VariableInputError, input);
}
var inputIterator = new WarewolfIterator(warewolfEvalResult);
warewolfListIterator.AddVariableToIterateOn(inputIterator);
var counter = 1;
while (warewolfListIterator.HasMoreData())
{
var result = warewolfListIterator.FetchNextValue(inputIterator);
dataObject.Environment.Assign(Result, result, update == 0 ? counter : update);
counter++;
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(Result, dataObject.Environment, update);
}
allErrors.MergeErrors(errors);
}
catch (Exception ex)
{
Dev2Logger.Error("Calculate Exception", ex, GlobalConstants.WarewolfError);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCalculateActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(Result, dataObject.Environment, update);
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
// BUG 9706 - 2013.06.22 - TWR : refactored
void DispatchDebugErrors(ErrorResultTO errors, IDSFDataObject dataObject, StateType stateType)
{
if(errors.HasErrors() && dataObject.IsDebugMode())
{
Guid parentInstanceId;
Guid.TryParse(dataObject.ParentInstanceID, out parentInstanceId);
var debugState = new DebugState
{
ID = dataObject.DataListID,
ParentID = parentInstanceId,
WorkspaceID = dataObject.WorkspaceID,
StateType = stateType,
StartTime = DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
DisplayName = dataObject.ServiceName,
IsSimulation = dataObject.IsOnDemandSimulation,
ServerID = dataObject.ServerID,
OriginatingResourceID = dataObject.ResourceID,
OriginalInstanceID = dataObject.OriginalInstanceID,
SessionID = dataObject.DebugSessionID,
EnvironmentID = dataObject.EnvironmentID,
ClientID = dataObject.ClientID,
Server = string.Empty,
Version = string.Empty,
Name = GetType().Name,
HasError = errors.HasErrors(),
ErrorMessage = errors.MakeDisplayReady()
};
DebugDispatcher.Instance.Write(debugState, dataObject.RemoteInvoke, dataObject.RemoteInvokerID);
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
dataObject.EnvironmentID = EnvironmentID?.Expression == null ? Guid.Empty : Guid.Parse(EnvironmentID.Expression.ToString());
dataObject.RemoteServiceType = Type?.Expression?.ToString() ?? "";
ParentServiceName = dataObject.ServiceName;
var parentServiceName = string.Empty;
var serviceName = string.Empty;
var isRemote = dataObject.IsRemoteWorkflow();
if ((isRemote || dataObject.IsRemoteInvokeOverridden) && dataObject.EnvironmentID == Guid.Empty)
{
dataObject.IsRemoteInvokeOverridden = true;
}
var oldResourceId = dataObject.ResourceID;
InitializeDebug(dataObject);
try
{
if (ServiceServer != Guid.Empty)
{
dataObject.RemoteInvokerID = ServiceServer.ToString();
}
dataObject.RunWorkflowAsync = RunWorkflowAsync;
var resourceId = dataObject.ResourceID;
if (resourceId != Guid.Empty)
{
dataObject.ResourceID = resourceId;
}
parentServiceName = dataObject.ParentServiceName;
serviceName = dataObject.ServiceName;
dataObject.ParentServiceName = serviceName;
_previousInstanceId = dataObject.ParentInstanceID;
dataObject.ParentID = oldResourceId;
dataObject.ParentInstanceID = UniqueID;
dataObject.ParentWorkflowInstanceId = ParentWorkflowInstanceId;
if (!DeferExecution)
{
var tmpErrors = new ErrorResultTO();
var esbChannel = dataObject.EsbChannel;
if (esbChannel == null)
{
throw new Exception(ErrorResource.NullESBChannel);
}
dataObject.ServiceName = ServiceName; // set up for sub-exection ;)
dataObject.ResourceID = ResourceID.Expression == null ? Guid.Empty : Guid.Parse(ResourceID.Expression.ToString());
BeforeExecutionStart(dataObject, allErrors);
if (dataObject.IsDebugMode() || dataObject.RunWorkflowAsync && !dataObject.IsFromWebServer)
{
DispatchDebugStateAndUpdateRemoteServer(dataObject, StateType.Before, update);
}
allErrors.MergeErrors(tmpErrors);
ExecutionImpl(esbChannel, dataObject, InputMapping, OutputMapping, out tmpErrors, update);
allErrors.MergeErrors(tmpErrors);
AfterExecutionCompleted(tmpErrors);
allErrors.MergeErrors(tmpErrors);
dataObject.ServiceName = ServiceName;
}
}
catch (Exception err)
{
dataObject.Environment.Errors.Add(err.Message);
}
finally
{
DebugOutput(dataObject, update, allErrors, parentServiceName, serviceName, oldResourceId);
}
}
/// <summary>
/// Invokes the workflow impl.
/// </summary>
/// <param name="workflowActivity">The workflow activity.</param>
/// <param name="dataTransferObject">The data transfer object.</param>
/// <param name="executionExtensions">The execution extensions.</param>
/// <param name="instanceId">The instance id.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="bookmarkName">Name of the bookmark.</param>
/// <param name="isDebug">if set to <c>true</c> [is debug].</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
private IDSFDataObject InvokeWorkflowImpl(Activity workflowActivity, IDSFDataObject dataTransferObject, IList<object> executionExtensions, Guid instanceId, IWorkspace workspace, string bookmarkName, bool isDebug, out ErrorResultTO errors)
{
Tracker.TrackEvent(TrackerEventGroup.Workflows, TrackerEventName.Executed, string.Format("RES-{0}", dataTransferObject.ResourceID));
if(AllErrors == null)
{
AllErrors = new ErrorResultTO();
}
IExecutionToken exeToken = new ExecutionToken { IsUserCanceled = false };
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.StartedCallback);
WorkflowApplication wfApp = InitEntryPoint(workflowActivity, dataTransferObject, executionExtensions, instanceId, workspace, bookmarkName);
errors = new ErrorResultTO();
if(wfApp != null)
{
// add termination token
wfApp.Extensions.Add(exeToken);
using(ManualResetEventSlim waitHandle = new ManualResetEventSlim(false))
{
WorkflowApplicationRun run = new WorkflowApplicationRun(this, waitHandle, dataTransferObject, wfApp, workspace, executionExtensions, FetchParentInstanceId(dataTransferObject), isDebug, errors, exeToken);
if(instanceId == Guid.Empty)
{
Interlocked.Increment(ref Balance);
run.Run();
_runTime = DateTime.Now;
waitHandle.Wait();
}
else
{
Interlocked.Increment(ref Balance);
try
{
if(!string.IsNullOrEmpty(bookmarkName))
{
dataTransferObject.CurrentBookmarkName = bookmarkName;
run.Resume(dataTransferObject);
}
else
{
run.Run();
_runTime = DateTime.Now;
}
waitHandle.Wait();
}
catch(InstanceNotReadyException e1)
{
Interlocked.Decrement(ref Balance);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
errors.AddError(e1.Message);
AllErrors.AddError(e1.Message);
return null;
}
catch(InstancePersistenceException e2)
{
Interlocked.Decrement(ref Balance);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
errors.AddError(e2.Message);
AllErrors.AddError(e2.Message);
return run.DataTransferObject.Clone();
}
catch(Exception ex)
{
Interlocked.Decrement(ref Balance);
errors.AddError(ex.Message);
AllErrors.AddError(ex.Message);
ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback);
return run.DataTransferObject.Clone();
}
}
Interlocked.Decrement(ref Balance);
dataTransferObject = run.DataTransferObject.Clone();
var wfappUtils = new WfApplicationUtils();
ErrorResultTO invokeErrors;
if (dataTransferObject.IsDebugMode())
{
wfappUtils.DispatchDebugState(dataTransferObject, StateType.End, AllErrors.HasErrors(), AllErrors.MakeDisplayReady(), out invokeErrors, _runTime, false, true);
}
//AllErrors.MergeErrors(invokeErrors);
// avoid memory leak ;)
run.Dispose();
}
}
else
{
errors.AddError("Internal System Error : Could not create workflow execution wrapper");
}
return dataTransferObject;
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
_indexCounter = 1;
ErrorResultTO allErrors = new ErrorResultTO();
try
{
var sharepointReadListTos = _sharepointUtils.GetValidReadListItems(ReadListItems).ToList();
if (sharepointReadListTos.Any())
{
var sharepointSource = ResourceCatalog.Instance.GetResource <SharepointSource>(dataObject.WorkspaceID, SharepointServerResourceId);
if (sharepointSource == null)
{
var contents = ResourceCatalog.Instance.GetResourceContents(dataObject.WorkspaceID, SharepointServerResourceId);
sharepointSource = new SharepointSource(contents.ToXElement());
}
var env = dataObject.Environment;
if (dataObject.IsDebugMode())
{
AddInputDebug(env, update);
}
var sharepointHelper = sharepointSource.CreateSharepointHelper();
var fields = sharepointHelper.LoadFieldsForList(SharepointList, false);
using (var ctx = sharepointHelper.GetContext())
{
var camlQuery = _sharepointUtils.BuildCamlQuery(env, FilterCriteria, fields, update);
List list = ctx.Web.Lists.GetByTitle(SharepointList);
var listItems = list.GetItems(camlQuery);
ctx.Load(listItems);
ctx.ExecuteQuery();
var index = 1;
foreach (var listItem in listItems)
{
foreach (var sharepointReadListTo in sharepointReadListTos)
{
var variableName = sharepointReadListTo.VariableName;
var fieldToName = sharepointReadListTo.FieldName;
var fieldName = fields.FirstOrDefault(field => field.Name == fieldToName);
if (fieldName != null)
{
var listItemValue = "";
try
{
var sharepointValue = listItem[fieldName.InternalName];
if (sharepointValue != null)
{
var sharepointVal = GetSharepointValue(sharepointValue);
listItemValue = sharepointVal.ToString();
}
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
//Ignore sharepoint exception on retrieval not all fields can be retrieved.
}
var correctedVariable = variableName;
if (DataListUtil.IsValueRecordset(variableName) && DataListUtil.IsStarIndex(variableName))
{
correctedVariable = DataListUtil.ReplaceStarWithFixedIndex(variableName, index);
}
env.AssignWithFrame(new AssignValue(correctedVariable, listItemValue), update);
}
}
index++;
}
}
env.CommitAssign();
AddOutputDebug(dataObject, env, update);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("SharepointReadListActivity", e);
allErrors.AddError(e.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("SharepointReadListActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
