public void WarewolfListIterator_FetchNextValue_NoValuesToIterateOn_ReturnsException()
{
//------------Setup for test--------------------------
var env = new ExecutionEnvironment();
var warewolfListIterator = new WarewolfListIterator();
var warewolfIterator = new WarewolfIterator(env.Eval("[[rec().a]]", 0));
//------------Execute Test---------------------------
var value = warewolfListIterator.FetchNextValue(warewolfIterator);
//------------Assert Results-------------------------
Assert.IsNull(value);
}
public void WarewolfListIterator_FetchNextValue_HasValues_ShouldReturnValue()
{
//------------Setup for test--------------------------
var env = new ExecutionEnvironment();
env.Assign("[[rec().a]]", "Test", 0);
env.Assign("[[rec().a]]", "Test2", 0);
env.Assign("[[rec().a]]", "Test4", 0);
env.Assign("[[rec().a]]", "Test5", 0);
env.CommitAssign();
var warewolfListIterator = new WarewolfListIterator();
var warewolfIterator = new WarewolfIterator(env.Eval("[[rec().a]]", 0));
warewolfListIterator.AddVariableToIterateOn(warewolfIterator);
//------------Execute Test---------------------------
var value = warewolfListIterator.FetchNextValue(warewolfIterator);
//------------Assert Results-------------------------
Assert.AreEqual("Test5", value);
}
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);
Dictionary <string, IWarewolfIterator> listOfIterators = new Dictionary <string, IWarewolfIterator>();
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, true);
using (var ctx = sharepointHelper.GetContext())
{
var camlQuery = _sharepointUtils.BuildCamlQuery(env, FilterCriteria, fields, update, RequireAllCriteriaToMatch);
List list = ctx.Web.Lists.GetByTitle(SharepointList);
var listItems = list.GetItems(camlQuery);
ctx.Load(listItems);
ctx.ExecuteQuery();
var iteratorList = new WarewolfListIterator();
foreach (var sharepointReadListTo in sharepointReadListTos)
{
var warewolfIterator = new WarewolfIterator(env.Eval(sharepointReadListTo.VariableName, update));
iteratorList.AddVariableToIterateOn(warewolfIterator);
listOfIterators.Add(sharepointReadListTo.InternalName, warewolfIterator);
}
foreach (var listItem in listItems)
{
foreach (var warewolfIterator in listOfIterators)
{
listItem[warewolfIterator.Key] = warewolfIterator.Value.GetNextValue();
}
listItem.Update();
ctx.ExecuteQuery();
}
}
env.Assign(Result, "Success", update);
AddOutputDebug(dataObject, env, update);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("SharepointUpdateListItemActivity", e);
allErrors.AddError(e.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
dataObject.Environment.Assign(Result, "Failed", update);
DisplayAndWriteError("SharepointUpdateListItemActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
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();
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 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);
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);
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 void ExecuteImpl(IDataListCompiler compiler, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
#region Create OutputFormatter
// ReSharper disable RedundantAssignment
IOutputFormatter outputFormatter = null;
// ReSharper restore RedundantAssignment
try
{
outputFormatter = GetOutputFormatter(Service);
}
catch (Exception)
{
if (HandlesOutputFormatting)
{
errors.AddError(
string.Format("Output format in service action {0} is invalid. Please edit and remap.",
Service.ResourceName));
return;
}
}
if (HandlesOutputFormatting && outputFormatter == null)
{
errors.AddError(string.Format("Output format in service action {0} is invalid.", Service.ResourceName));
return;
}
#endregion
try
{
ErrorResultTO invokeErrors;
var itrs = new List <IWarewolfIterator>(5);
IWarewolfListIterator itrCollection = new WarewolfListIterator();
ServiceMethod method = Service.Method;
var inputs = method.Parameters;
if (inputs.Count == 0)
{
ExecuteService(inputs as IEnumerable <MethodParameter>, out invokeErrors, outputFormatter);
errors.MergeErrors(invokeErrors);
}
else
{
#region Build iterators for each ServiceActionInput
var inputDefs = DataListFactory.CreateInputParser().Parse(InstanceInputDefinitions);
foreach (MethodParameter sai in inputs)
{
string val = sai.Name;
string toInject = "NULL";
if (val != null)
{
var sai1 = sai;
var dev2Definitions = inputDefs.Where(definition => definition.Name == sai1.Name);
var definitions = dev2Definitions as IDev2Definition[] ?? dev2Definitions.ToArray();
if (definitions.Count() == 1)
{
toInject = DataListUtil.IsEvaluated(definitions[0].RawValue) ? DataListUtil.AddBracketsToValueIfNotExist(definitions[0].RawValue) : definitions[0].RawValue;
}
}
else if (!sai.EmptyToNull)
{
toInject = sai.DefaultValue;
}
var paramIterator = new WarewolfIterator(DataObj.Environment.Eval(toInject));
itrCollection.AddVariableToIterateOn(paramIterator);
itrs.Add(paramIterator);
}
#endregion
while (itrCollection.HasMoreData())
{
ExecuteService(Service.Method.Parameters, itrCollection, itrs, out invokeErrors, outputFormatter);
errors.MergeErrors(invokeErrors);
}
}
}
finally
{
var disposable = Service as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
// ensure errors bubble up ;)
errors.MergeErrors(ErrorResult);
}
}
#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 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 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();
try
{
var dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
colItr.FetchNextValue(unameItr),
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst);
string result = broker.Delete(dstEndPoint);
outputs[0].OutputStrings.Add(result);
}
catch (Exception e)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure"));
allErrors.AddError(e.Message);
break;
}
}
return(outputs);
}
private void ExecuteConcreteAction(IList <OutputTO> outputs, WarewolfListIterator colItr, SharepointSource sharepointSource, WarewolfIterator serverInputFromItr, WarewolfIterator serverInputFromTo)
{
var serverPath = colItr.FetchNextValue(serverInputFromItr);
var localPath = colItr.FetchNextValue(serverInputFromTo);
if (DataListUtil.IsValueRecordset(Result) && DataListUtil.GetRecordsetIndexType(Result) != enRecordsetIndexType.Numeric)
{
if (DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
var recsetName = DataListUtil.ExtractRecordsetNameFromValue(Result);
var fieldName = DataListUtil.ExtractFieldNameFromValue(Result);
var newPath = CopyFile(sharepointSource, serverPath, localPath);
var indexToUpsertTo = 1;
foreach (var file in newPath)
{
var 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)
{
AddOutputsForBlankIndex(outputs, sharepointSource, serverPath, localPath);
}
}
}
else
{
var newPath = CopyFile(sharepointSource, serverPath, localPath);
var xmlList = string.Join(",", newPath.Select(c => c));
outputs.Add(DataListFactory.CreateOutputTO(Result));
outputs.Last().OutputStrings.Add(xmlList);
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
IExecutionToken exeToken = dataObject.ExecutionToken;
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(CommandFileName, "Command", dataObject.Environment, update));
}
var itr = new WarewolfIterator(dataObject.Environment.Eval(CommandFileName, update));
if (!allErrors.HasErrors())
{
while (itr.HasMoreData())
{
var val = itr.GetNextValue();
{
if (string.IsNullOrEmpty(val))
{
throw new Exception("Empty script to execute");
}
StreamReader errorReader;
StringBuilder outputReader;
if (!ExecuteProcess(val, exeToken, out errorReader, out outputReader))
{
return;
}
allErrors.AddError(errorReader.ReadToEnd());
var bytes = Encoding.Default.GetBytes(outputReader.ToString().Trim());
string readValue = Encoding.ASCII.GetString(bytes).Replace("?", " ");
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
foreach (var region in DataListCleaningUtils.SplitIntoRegions(CommandResult))
{
if (dataObject.Environment != null)
{
dataObject.Environment.Assign(region, readValue, update);
}
}
errorReader.Close();
}
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(CommandResult))
{
AddDebugOutputItem(new DebugEvalResult(CommandResult, "", dataObject.Environment, update));
}
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFCommandLine", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfExecuteCommandLineActivity", allErrors);
if (dataObject.Environment != null)
{
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(CommandResult, null, update);
}
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", CommandResult, ""));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
if (!string.IsNullOrEmpty(_fullPath))
{
File.Delete(_fullPath);
}
}
}
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);
Dictionary <string, IWarewolfIterator> listOfIterators = new Dictionary <string, IWarewolfIterator>();
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, true);
using (var ctx = sharepointHelper.GetContext())
{
var list = sharepointHelper.LoadFieldsForList(SharepointList, ctx, true);
var iteratorList = new WarewolfListIterator();
foreach (var sharepointReadListTo in sharepointReadListTos)
{
var warewolfIterator = new WarewolfIterator(env.Eval(sharepointReadListTo.VariableName, update));
iteratorList.AddVariableToIterateOn(warewolfIterator);
listOfIterators.Add(sharepointReadListTo.FieldName, warewolfIterator);
}
while (iteratorList.HasMoreData())
{
var itemCreateInfo = new ListItemCreationInformation();
var listItem = list.AddItem(itemCreateInfo);
foreach (var warewolfIterator in listOfIterators)
{
var sharepointFieldTo = fields.FirstOrDefault(to => to.Name == warewolfIterator.Key);
if (sharepointFieldTo != null)
{
object value = warewolfIterator.Value.GetNextValue();
value = _sharepointUtils.CastWarewolfValueToCorrectType(value, sharepointFieldTo.Type);
listItem[sharepointFieldTo.InternalName] = value;
}
}
listItem.Update();
ctx.ExecuteQuery();
}
}
env.Assign(Result, "Success", update);
AddOutputDebug(dataObject, env, update);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("SharepointReadListActivity", e);
allErrors.AddError(e.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
dataObject.Environment.Assign(Result, "Failed", update);
DisplayAndWriteError("SharepointReadListActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
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>();
_indexCounter = 1;
ErrorResultTO allErrors = new ErrorResultTO();
var env = dataObject.Environment;
WarewolfListIterator iter = new WarewolfListIterator();
InitializeDebug(dataObject);
try
{
var sourceString = SourceString ?? "";
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(sourceString, "String to Split", env));
AddDebugInputItem(new DebugItemStaticDataParams(ReverseOrder ? "Backward" : "Forward", "Process Direction"));
AddDebugInputItem(new DebugItemStaticDataParams(SkipBlankRows ? "Yes" : "No", "Skip blank rows"));
AddDebug(ResultsCollection, dataObject.Environment);
}
var res = new WarewolfIterator(env.Eval(sourceString));
iter.AddVariableToIterateOn(res);
IDictionary <string, int> positions = new Dictionary <string, int>();
CleanArguments(ResultsCollection);
ResultsCollection.ToList().ForEach(a =>
{
if (!positions.ContainsKey(a.OutputVariable))
{
positions.Add(a.OutputVariable, 1);
}
IsSingleValueRule.ApplyIsSingleValueRule(a.OutputVariable, allErrors);
});
bool singleInnerIteration = ArePureScalarTargets(ResultsCollection);
var resultsEnumerator = ResultsCollection.GetEnumerator();
var debugDictionary = new List <string>();
while (res.HasMoreData())
{
const int OpCnt = 0;
var item = res.GetNextValue(); // item is the thing we split on
if (!string.IsNullOrEmpty(item))
{
string val = item;
var blankRows = new List <int>();
if (SkipBlankRows)
{
var strings = val.Split(new[] { Environment.NewLine, "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
var newSourceString = string.Join(Environment.NewLine, strings);
val = newSourceString;
}
else
{
var strings = val.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
for (int blankRow = 0; blankRow < strings.Length; blankRow++)
{
if (String.IsNullOrEmpty(strings[blankRow]))
{
blankRows.Add(blankRow);
}
}
}
ErrorResultTO errors;
IDev2Tokenizer tokenizer = CreateSplitPattern(ref val, ResultsCollection, env, out errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
if (tokenizer != null)
{
int pos = 0;
int end = (ResultsCollection.Count - 1);
// track used tokens so we can adjust flushing ;)
while (tokenizer.HasMoreOps())
{
var currentval = resultsEnumerator.MoveNext();
if (!currentval)
{
if (singleInnerIteration)
{
break;
}
resultsEnumerator.Reset();
resultsEnumerator.MoveNext();
}
string tmp = tokenizer.NextToken();
if (tmp.StartsWith(Environment.NewLine) && !SkipBlankRows)
{
resultsEnumerator.Reset();
while (resultsEnumerator.MoveNext())
{
var tovar = resultsEnumerator.Current.OutputVariable;
if (!String.IsNullOrEmpty(tovar))
{
var assignToVar = ExecutionEnvironment.ConvertToIndex(tovar, positions[tovar]);
env.AssignWithFrame(new AssignValue(assignToVar, ""));
positions[tovar] = positions[tovar] + 1;
}
}
resultsEnumerator.Reset();
resultsEnumerator.MoveNext();
}
if (blankRows.Contains(OpCnt) && blankRows.Count != 0)
{
tmp = tmp.Replace(Environment.NewLine, "");
while (pos != end + 1)
{
pos++;
}
}
var outputVar = resultsEnumerator.Current.OutputVariable;
if (!String.IsNullOrEmpty(outputVar))
{
var assignVar = ExecutionEnvironment.ConvertToIndex(outputVar, positions[outputVar]);
if (ExecutionEnvironment.IsRecordsetIdentifier(assignVar))
{
env.AssignWithFrame(new AssignValue(assignVar, tmp));
}
else if (ExecutionEnvironment.IsScalar(assignVar) && positions[outputVar] == 1)
{
env.AssignWithFrame(new AssignValue(assignVar, tmp));
}
else
{
env.AssignWithFrame(new AssignValue(assignVar, tmp));
}
positions[outputVar] = positions[outputVar] + 1;
}
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
var outputVarTo = resultsEnumerator.Current.OutputVariable;
AddDebugItem(new DebugEvalResult(outputVarTo, "", env), debugItem);
if (!debugDictionary.Contains(outputVarTo))
{
debugDictionary.Add(outputVarTo);
}
}
if (pos == end)
{
}
else
{
pos++;
}
}
}
}
}
env.CommitAssign();
if (singleInnerIteration)
{
break;
}
}
if (dataObject.IsDebugMode())
{
var outputIndex = 1;
foreach (var varDebug in debugDictionary)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
var dataSplitUsesStarForOutput = varDebug.Replace("().", "(*).");
AddDebugItem(new DebugEvalResult(dataSplitUsesStarForOutput, "", env), debugItem);
_debugOutputs.Add(debugItem);
outputIndex++;
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFDataSplit", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfDataSplitActivity", 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)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDev2IndexFinder indexFinder = new Dev2IndexFinder();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
var outerIteratorCollection = new WarewolfListIterator();
var innerIteratorCollection = new WarewolfListIterator();
allErrors.MergeErrors(errors);
#region Iterate and Find Index
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugEvalResult(InField, "In Field", dataObject.Environment));
AddDebugInputItem(new DebugItemStaticDataParams(Index, "Index"));
AddDebugInputItem(new DebugEvalResult(Characters, "Characters", dataObject.Environment));
AddDebugInputItem(new DebugItemStaticDataParams(Direction, "Direction"));
}
var itrChar = new WarewolfIterator(dataObject.Environment.Eval(Characters));
outerIteratorCollection.AddVariableToIterateOn(itrChar);
var completeResultList = new List <string>();
while (outerIteratorCollection.HasMoreData())
{
allErrors.MergeErrors(errors);
errors.ClearErrors();
var itrInField = new WarewolfIterator(dataObject.Environment.Eval(InField));
innerIteratorCollection.AddVariableToIterateOn(itrInField);
string chars = outerIteratorCollection.FetchNextValue(itrChar);
while (innerIteratorCollection.HasMoreData())
{
if (!string.IsNullOrEmpty(InField) && !string.IsNullOrEmpty(Characters))
{
var val = innerIteratorCollection.FetchNextValue(itrInField);
if (val != null)
{
IEnumerable <int> returedData = indexFinder.FindIndex(val, Index, chars, Direction, MatchCase, StartIndex);
completeResultList.AddRange(returedData.Select(value => value.ToString(CultureInfo.InvariantCulture)).ToList());
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
}
}
}
}
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
if (DataListUtil.IsValueRecordset(Result))
{
var rsType = DataListUtil.GetRecordsetIndexType(Result);
if (rsType == enRecordsetIndexType.Numeric)
{
dataObject.Environment.Assign(Result, string.Join(",", completeResultList));
allErrors.MergeErrors(errors);
}
else
{
var idx = 1;
foreach (var res in completeResultList)
{
if (rsType == enRecordsetIndexType.Blank)
{
dataObject.Environment.Assign(Result, res);
}
if (rsType == enRecordsetIndexType.Star)
{
var expression = DataListUtil.CreateRecordsetDisplayValue(DataListUtil.ExtractRecordsetNameFromValue(Result), DataListUtil.ExtractFieldNameFromValue(Result), idx.ToString());
dataObject.Environment.Assign(DataListUtil.AddBracketsToValueIfNotExist(expression), res);
idx++;
}
}
}
}
else
{
dataObject.Environment.Assign(Result, string.Join(",", completeResultList));
}
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
#endregion
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFFindActivity", e);
allErrors.AddError(e.Message);
}
finally
{
#region Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfIndexActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
#endregion
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
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 AddItemsToIterator(IExecutionEnvironment environment, int update)
{
_archPassItr = new WarewolfIterator(environment.Eval(ArchivePassword, update));
ColItr.AddVariableToIterateOn(_archPassItr);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
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, update));
if (Find != null)
{
AddDebugInputItem(new DebugEvalResult(Find, "Find", dataObject.Environment, update));
}
if (ReplaceWith != null)
{
AddDebugInputItem(new DebugEvalResult(ReplaceWith, "Replace With", dataObject.Environment, update));
}
}
}
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
{
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)), update);
}
replacementTotal += replacementCount;
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(Result))
{
if (replacementCount > 0)
{
AddDebugOutputItem(new DebugEvalResult(s, "", dataObject.Environment, update));
}
}
}
}
}
}
if (!string.IsNullOrEmpty(Result))
{
dataObject.Environment.Assign(Result, replacementTotal.ToString(CultureInfo.InvariantCulture), update);
}
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
if (!string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
// 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, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
#pragma warning disable S1541 // Methods and properties should not be too complex
#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
private void TryExecuteTool(IDSFDataObject dataObject, int update, IDev2MergeOperations mergeOperations, ErrorResultTO allErrors, ErrorResultTO errorResultTo)
#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
#pragma warning restore S1541 // Methods and properties should not be too complex
{
IWarewolfListIterator warewolfListIterator = new WarewolfListIterator();
allErrors.MergeErrors(errorResultTo);
var 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
var dictionaryKey = 0;
foreach (DataMergeDTO row in MergeCollection)
{
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode())
{
var 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())
{
var 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]);
pos = AddErrorAndMerge(mergeOperations, allErrors, pos, val, at, pad);
}
}
if (!allErrors.HasErrors())
{
if (string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugItemStaticDataParams("", ""));
}
else
{
AddToErrorsToDebugOutput(dataObject, update, mergeOperations, allErrors, errorResultTo);
}
}
}
#endregion Iterate and Merge Data
}
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("DsfScriptingJavaScriptActivity", 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);
InitializeDebug(dataObject);
// Process if no errors
try
{
if (dataObject.IsDebugMode())
{
if (string.IsNullOrEmpty(Input1))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(GlobalConstants.GlobalDefaultNowFormat), "now()", "Input 1", "="));
}
else
{
AddDebugInputItem(Input1, "Input 1", dataObject.Environment, update);
}
if (string.IsNullOrEmpty(Input2))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(GlobalConstants.GlobalDefaultNowFormat), "now()", "Input 2", "="));
}
else
{
AddDebugInputItem(Input2, "Input 2", dataObject.Environment, update);
}
AddDebugInputItem(InputFormat, "Input Format", dataObject.Environment, update);
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, update));
colItr.AddVariableToIterateOn(input1Itr);
var evalInp2 = dataObject.Environment.EvalStrict(string.IsNullOrEmpty(Input2) ? GlobalConstants.CalcExpressionNow : Input2, update);
var input2Itr = new WarewolfIterator(evalInp2);
colItr.AddVariableToIterateOn(input2Itr);
var ifItr = new WarewolfIterator(dataObject.Environment.Eval(InputFormat ?? string.Empty, update));
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)
{
if (update == 0)
{
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, update);
}
}
else
{
DoDebugOutput(dataObject, expression, update);
allErrors.AddError(error);
}
indexToUpsertTo++;
}
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, null, dataObject.Environment, update));
}
}
catch (Exception e)
{
Dev2Logger.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, 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>();
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, true), debugItem);
AddDebugItem(new DebugItemStaticDataParams(row.MergeType, "With"), debugItem);
AddDebugItem(new DebugEvalResult(row.At, "Using", dataObject.Environment), debugItem);
AddDebugItem(new DebugEvalResult(row.Padding, "Pad", dataObject.Environment), 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);
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 <DataASTMutable.WarewolfAtom>();
while (innerIterator.HasMoreData())
{
var stringToUse = "";
foreach (var warewolfIterator in innerListOfIters)
{
stringToUse += warewolfIterator.GetNextValue();
}
atomList.Add(DataASTMutable.WarewolfAtom.NewDataString(stringToUse));
}
var finalString = string.Join("", atomList);
var inputListResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomListresult(new WarewolfAtomList <DataASTMutable.WarewolfAtom>(DataASTMutable.WarewolfAtom.Nothing, atomList));
if (DataListUtil.IsFullyEvaluated(finalString))
{
inputListResult = dataObject.Environment.Eval(finalString);
}
var inputIterator = new WarewolfIterator(inputListResult);
var atIterator = new WarewolfIterator(dataObject.Environment.Eval(row.At));
var paddingIterator = new WarewolfIterator(dataObject.Environment.Eval(row.Padding));
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("The 'Using' value cannot be blank.");
}
int atValue;
if (!Int32.TryParse(at, out atValue) || atValue < 0)
{
allErrors.AddError("The 'Using' value must be a real number.");
}
if (pad.Length > 1)
{
allErrors.AddError("'Padding' must be a single character");
}
}
else
{
if (MergeCollection[pos].MergeType == "Chars" && string.IsNullOrEmpty(at))
{
allErrors.AddError("The 'Using' value cannot be blank.");
}
}
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());
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
}
}
#endregion Iterate and Merge Data
}
catch (Exception e)
{
Dev2Logger.Log.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);
DispatchDebugState(dataObject, StateType.After);
}
#endregion
}
}
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)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
try
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(dataObject.Environment);
}
string 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);
var scalarResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && scalarResult.Item.IsNothing)
{
throw new NullValueInVariableException("Error with variables in input.", input);
}
var inputIterator = new WarewolfIterator(warewolfEvalResult);
warewolfListIterator.AddVariableToIterateOn(inputIterator);
while (warewolfListIterator.HasMoreData())
{
var result = warewolfListIterator.FetchNextValue(inputIterator);
dataObject.Environment.Assign(Result, result);
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(Result, dataObject.Environment);
}
allErrors.MergeErrors(errors);
}
catch (Exception ex)
{
Dev2Logger.Log.Error("Calculate Exception", ex);
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);
}
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
private int TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, int indexToUpsertTo, IExchange runtimeSource)
{
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())
{
var result = _emailSender.SendEmail(runtimeSource, colItr, toItr, ccItr, bccItr, subjectItr, bodyItr, attachmentsItr, out ErrorResultTO errors, IsHtml);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
indexToUpsertTo = UpsertResult(indexToUpsertTo, dataObject.Environment, result, update);
}
}
if (IsDebug && !allErrors.HasErrors() && !string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
else
{
if (IsDebug)
{
AddDebugInputItem(To, "To");
AddDebugInputItem(Subject, "Subject");
AddDebugInputItem(Body, "Body");
}
}
return(indexToUpsertTo);
}
private void CheckForErrors(IDSFDataObject dataObject, int update, IDev2IndexFinder indexFinder, ErrorResultTO allErrors, ErrorResultTO errors, WarewolfListIterator innerIteratorCollection, List <string> completeResultList, WarewolfIterator itrInField, string chars)
{
if (!string.IsNullOrEmpty(InField) && !string.IsNullOrEmpty(Characters))
{
var val = innerIteratorCollection.FetchNextValue(itrInField);
if (val != null)
{
var returedData = indexFinder.FindIndex(val, Index, chars, Direction, MatchCase, StartIndex);
completeResultList.AddRange(returedData.Select(value => value.ToString(CultureInfo.InvariantCulture)).ToList());
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
dataObject.Environment.Assign(Result, string.Join(",", completeResultList), update);
allErrors.MergeErrors(errors);
}
}
}
}
IErrorResultTO TryExecute(IDSFDataObject dataObject, int update, IDev2ReplaceOperation replaceOperation, ref IErrorResultTO errors, IErrorResultTO allErrors, ref int replacementCount, ref int replacementTotal, IList <string> toSearch, IWarewolfListIterator iteratorCollection, WarewolfIterator itrFind, WarewolfIterator itrReplace)
{
var counter = 1;
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)
{
ExecuteEachField(dataObject, update, replaceOperation, ref errors, allErrors, ref replacementCount, ref replacementTotal, ref counter, findValue, replaceWithValue, s);
}
}
return(allErrors);
}
public static string GetXmlOutputFromEnvironment(IDSFDataObject dataObject, string dataList, int update)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("<DataList>");
var scalarOutputs = dataListTO.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Outputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var i = 1;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfEvalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.Nothing);
try
{
warewolfEvalResult = environment.Eval(name, update, false);
}
// ReSharper disable once RESP510236
// ReSharper disable once RESP510241
catch (Exception e)
{
Dev2Logger.Log.Debug("Null Variable", e);
}
var warewolfIterator = new WarewolfIterator(warewolfEvalResult);
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
while (warewolfListIterators.HasMoreData())
{
result.Append("<");
result.Append(groupedRecSet.Key);
result.Append(string.Format(" Index=\"{0}\">", i));
foreach (var namedIterator in iterators)
{
try
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("<");
result.Append(namedIterator.Key);
result.Append(">");
result.Append(value);
result.Append("</");
result.Append(namedIterator.Key);
result.Append(">");
}
catch (Exception e)
{
Dev2Logger.Log.Debug(e.Message, e);
}
}
result.Append("</");
result.Append(groupedRecSet.Key);
result.Append(">");
i++;
}
}
foreach (var output in scalarOutputs)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output), update, false);
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("<");
result.Append(output);
result.Append(">");
result.Append(scalarResult.Item);
result.Append("</");
result.Append(output);
result.Append(">");
}
}
}
result.Append("</DataList>");
return(result.ToString());
}
private void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, ErrorResultTO errors)
{
if (dataObject.IsDebugMode())
{
if (string.IsNullOrEmpty(Input1))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(GlobalConstants.PreviousDev2DotNetDefaultDateTimeFormat), "now()", "Input 1", "="));
}
else
{
AddDebugInputItem(Input1, "Input 1", dataObject.Environment, update);
}
if (string.IsNullOrEmpty(Input2))
{
AddDebugInputItem(new DebugItemStaticDataParams(DateTime.Now.ToString(GlobalConstants.PreviousDev2DotNetDefaultDateTimeFormat), "now()", "Input 2", "="));
}
else
{
AddDebugInputItem(Input2, "Input 2", dataObject.Environment, update);
}
AddDebugInputItem(InputFormat, "Input Format", dataObject.Environment, update);
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, update));
colItr.AddVariableToIterateOn(input1Itr);
var evalInp2 = dataObject.Environment.EvalStrict(string.IsNullOrEmpty(Input2) ? GlobalConstants.CalcExpressionNow : Input2, update);
var input2Itr = new WarewolfIterator(evalInp2);
colItr.AddVariableToIterateOn(input2Itr);
var ifItr = new WarewolfIterator(dataObject.Environment.Eval(InputFormat ?? string.Empty, update));
colItr.AddVariableToIterateOn(ifItr);
var indexToUpsertTo = 1;
while (colItr.HasMoreData())
{
var transObj = ConvertToDateTimeDiffTo(colItr.FetchNextValue(input1Itr),
colItr.FetchNextValue(input2Itr),
colItr.FetchNextValue(ifItr),
OutputType);
//Create a DateTimeComparer using the DateTimeConverterFactory
var comparer = DateTimeConverterFactory.CreateComparer();
var expression = Result;
if (comparer.TryCompare(transObj, out string result, out string error))
{
expression = GetExpression(update, indexToUpsertTo, expression);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
dataObject.Environment.Assign(expression, result, update);
}
}
public static string GetXmlInputFromEnvironment(IDSFDataObject dataObject, Guid workspaceGuid, string dataList)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("<" + "DataList" + ">");
var scalarOutputs = dataListTO.Inputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Inputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var i = 1;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfIterator = new WarewolfIterator(environment.Eval(name));
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
while (warewolfListIterators.HasMoreData())
{
result.Append("<");
result.Append(groupedRecSet.Key);
result.Append(string.Format(" Index=\"{0}\">", i));
foreach (var namedIterator in iterators)
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("<");
result.Append(namedIterator.Key);
result.Append(">");
result.Append(value);
result.Append("</");
result.Append(namedIterator.Key);
result.Append(">");
}
result.Append("</");
result.Append(groupedRecSet.Key);
result.Append(">");
i++;
}
}
foreach (var output in scalarOutputs)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output));
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("<");
result.Append(output);
result.Append(">");
result.Append(scalarResult.Item);
result.Append("</");
result.Append(output);
result.Append(">");
}
}
}
result.Append("</" + "DataList" + ">");
return(result.ToString());
}
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.AggregateCalculateTextConvertFormat, 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("Aggregate Calculate Exception", ex, GlobalConstants.WarewolfError);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfAggregateCalculateActivity", 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);
}
}
}
public static string GetJsonOutputFromEnvironment(IDSFDataObject dataObject, Guid workspaceGuid, string dataList)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("{");
var keyCnt = 0;
var scalarOutputs = dataListTO.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Outputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
var recSets = groupedRecSets as IGrouping <string, string>[] ?? groupedRecSets.ToArray();
foreach (var groupedRecSet in recSets)
{
var i = 0;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfIterator = new WarewolfIterator(environment.Eval(name));
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
result.Append("\"");
result.Append(groupedRecSet.Key);
result.Append("\" : [");
while (warewolfListIterators.HasMoreData())
{
int colIdx = 0;
result.Append("{");
foreach (var namedIterator in iterators)
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("\"");
result.Append(namedIterator.Key);
result.Append("\":\"");
result.Append(value);
result.Append("\"");
colIdx++;
if (colIdx < iterators.Count)
{
result.Append(",");
}
}
if (warewolfListIterators.HasMoreData())
{
result.Append("}");
result.Append(",");
}
}
result.Append("}");
result.Append("]");
i++;
if (i < recSets.Count())
{
result.Append(",");
}
}
var scalars = scalarOutputs as string[] ?? scalarOutputs.ToArray();
foreach (var output in scalars)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output));
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("\"");
result.Append(output);
result.Append("\":\"");
result.Append(scalarResult.Item);
result.Append("\"");
}
}
keyCnt++;
if (keyCnt < scalars.Count())
{
result.Append(",");
}
}
var jsonOutputFromEnvironment = result.ToString();
jsonOutputFromEnvironment += "}";
return(jsonOutputFromEnvironment);
}
public void WarewolfListIterator_FetchNextValue_WithIndex_HasMoreData_ShouldReturnTrue_WhenCounterSmallerThanLargestIndex()
{
//------------Setup for test--------------------------
var env = new ExecutionEnvironment();
env.Assign("[[rec().a]]", "Test", 0);
env.Assign("[[rec().a]]", "Test2", 0);
env.Assign("[[rec().a]]", "Test4", 0);
env.Assign("[[rec().a]]", "Test5", 0);
env.CommitAssign();
var warewolfListIterator = new WarewolfListIterator();
var warewolfIterator = new WarewolfIterator(env.Eval("[[rec().a]]", 0));
warewolfListIterator.AddVariableToIterateOn(warewolfIterator);
//------------Execute Test---------------------------
var hasMoreData = warewolfListIterator.HasMoreData();
//------------Assert Results-------------------------
Assert.IsTrue(hasMoreData);
}
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 serverInputFromItr = new WarewolfIterator(dataObject.Environment.Eval(ServerInputPathFrom, update));
colItr.AddVariableToIterateOn(serverInputFromItr);
var serverInputFromTo = new WarewolfIterator(dataObject.Environment.Eval(ServerInputPathTo, update));
colItr.AddVariableToIterateOn(serverInputFromTo);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(ServerInputPathFrom, "ServerInput Path From", dataObject.Environment, update);
AddDebugInputItem(ServerInputPathTo, "ServerInput Path To", dataObject.Environment, update);
}
while (colItr.HasMoreData())
{
try
{
var serverPath = colItr.FetchNextValue(serverInputFromItr);
var localPath = colItr.FetchNextValue(serverInputFromTo);
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 newPath = MoveFile(sharepointSource, serverPath, localPath);
int indexToUpsertTo = 1;
foreach (var file in newPath)
{
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 newPath = MoveFile(sharepointSource, serverPath, localPath);
foreach (var folder in newPath)
{
outputs.Add(DataListFactory.CreateOutputTO(Result, folder));
}
}
}
else
{
var newPath = MoveFile(sharepointSource, serverPath, localPath);
string xmlList = string.Join(",", newPath.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);
}
protected override IList <OutputTO> TryExecuteConcreteAction(IDSFDataObject context, out ErrorResultTO error, int update)
{
IList <OutputTO> outputs = new List <OutputTO>();
error = new ErrorResultTO();
var colItr = new WarewolfListIterator();
//get all the possible paths for all the string variables
var inputItr = new WarewolfIterator(context.Environment.Eval(InputPath, update));
colItr.AddVariableToIterateOn(inputItr);
var passItr = new WarewolfIterator(context.Environment.Eval(DecryptedPassword, update));
colItr.AddVariableToIterateOn(passItr);
var privateKeyItr = new WarewolfIterator(context.Environment.Eval(PrivateKeyFile ?? string.Empty, update));
colItr.AddVariableToIterateOn(privateKeyItr);
outputs.Add(DataListFactory.CreateOutputTO(Result));
if (context.IsDebugMode())
{
AddDebugInputItem(InputPath, "Input Path", context.Environment, update);
AddDebugInputItemUserNamePassword(context.Environment, update);
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
AddDebugInputItem(PrivateKeyFile, "Private Key File", context.Environment, update);
}
if (IsResultBase64)
{
AddDebugInputItem(IsResultBase64.ToString(), "Result As Base64", context.Environment, update);
}
}
while (colItr.HasMoreData())
{
var broker = ActivityIOFactory.CreateOperationsBroker();
var ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr),
Username,
colItr.FetchNextValue(passItr),
true, colItr.FetchNextValue(privateKeyItr));
var endpoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath);
try
{
if (IsResultBase64)
{
var result = broker.GetBytes(endpoint);
outputs[0].OutputStrings.Add(result.ToBase64String());
}
else
{
var result = broker.Get(endpoint);
outputs[0].OutputStrings.Add(result);
}
}
catch (Exception e)
{
outputs[0].OutputStrings.Add(null);
error.AddError(e.Message);
break;
}
}
return(outputs);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
if (WebRequestInvoker == null)
{
return;
}
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
allErrors.MergeErrors(errorsTo);
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(Url, "URL", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
var colItr = new WarewolfListIterator();
var urlitr = new WarewolfIterator(dataObject.Environment.Eval(Url, update));
var headerItr = new WarewolfIterator(dataObject.Environment.Eval(Headers, update));
colItr.AddVariableToIterateOn(urlitr);
colItr.AddVariableToIterateOn(headerItr);
while (colItr.HasMoreData())
{
var c = colItr.FetchNextValue(urlitr);
var headerValue = colItr.FetchNextValue(headerItr);
var headers = string.IsNullOrEmpty(headerValue)
? new string[0]
: headerValue.Split(new[] { '\n', '\r', ';' }, StringSplitOptions.RemoveEmptyEntries);
var headersEntries = new List <Tuple <string, string> >();
foreach (var header in headers)
{
var headerSegments = header.Split(':');
headersEntries.Add(new Tuple <string, string>(headerSegments[0], headerSegments[1]));
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(Headers, "Header", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
}
bool timeoutSecondsError = false;
if (!string.IsNullOrEmpty(TimeOutText))
{
int timeoutval;
if (int.TryParse(WarewolfDataEvaluationCommon.EvalResultToString(dataObject.Environment.Eval(TimeOutText, update)), out timeoutval))
{
if (timeoutval < 0)
{
allErrors.AddError(string.Format("Value of TimeoutSecondsText out of range: please specify a value between 0 and {0}.", int.MaxValue));
timeoutSecondsError = true;
}
else
{
TimeoutSeconds = timeoutval;
}
}
else
{
allErrors.AddError(string.Format("Value {0} for TimeoutSecondsText could not be interpreted as a numeric value.", TimeOutText));
timeoutSecondsError = true;
}
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(String.IsNullOrEmpty(TimeOutText) ? "100" : TimeOutText, "Time Out Seconds", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
}
if (!timeoutSecondsError)
{
var result = WebRequestInvoker.ExecuteRequest(Method,
c,
headersEntries, (TimeoutSeconds == 0 ? Timeout.Infinite : TimeoutSeconds * 1000) // important to list the parameter name here to see the conversion from seconds to milliseconds
);
allErrors.MergeErrors(errorsTo);
PushResultsToDataList(Result, result, dataObject, update);
}
else
{
throw new ApplicationException("Execution aborted - see error messages.");
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFWebGetRequest", e);
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfWebGetRequestActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
var expression = GetExpression(1);
PushResultsToDataList(expression, null, dataObject, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
