private void TryExecuteTool(IDSFDataObject dataObject, int update, ErrorResultTO allErrors)
{
var rs = DataListUtil.ExtractRecordsetNameFromValue(RecordsetName);
if (CountNumber == string.Empty)
{
allErrors.AddError(ErrorResource.BlankResultVariable);
}
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
{
if (dataObject.Environment.HasRecordSet(RecordsetName))
{
var count = dataObject.Environment.GetCount(rs);
var value = count.ToString();
dataObject.Environment.Assign(CountNumber, value, update);
AddDebugOutputItem(new DebugEvalResult(CountNumber, "", dataObject.Environment, update));
}
else
{
allErrors.AddError(String.Format(ErrorResource.NullRecordSet, RecordsetName));
}
}
}
private void TryExecuteTool(IDSFDataObject dataObject, int update, ErrorResultTO allErrors)
{
var rs = DataListUtil.ExtractRecordsetNameFromValue(RecordsetName);
if (RecordsLength == string.Empty)
{
allErrors.AddError(ErrorResource.BlankResultVariable);
}
if (dataObject.IsDebugMode())
{
var warewolfEvalResult = dataObject.Environment.Eval(RecordsetName.Replace("()", "(*)"), update);
if (warewolfEvalResult.IsWarewolfRecordSetResult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfRecordSetResult recsetResult)
{
AddDebugInputItem(new DebugItemWarewolfRecordset(recsetResult.Item, RecordsetName, "Recordset", "="));
}
//Because the environment eval above where you can only send through a recordset name and not list this code wont be reached.
//No Coverage added.
if (warewolfEvalResult.IsWarewolfAtomListresult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult atomListResult)
{
AddDebugInputItem(new DebugEvalResult(RecordsetName, "Recordset", dataObject.Environment, update));
}
}
var rule = new IsSingleValueRule(() => RecordsLength);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
if (dataObject.Environment.HasRecordSet(RecordsetName))
{
var count = dataObject.Environment.GetLength(rs);
var value = count.ToString();
dataObject.Environment.Assign(RecordsLength, value, update);
if (dataObject.Environment.Errors != null && !dataObject.Environment.Errors.Any())
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult(value, RecordsLength, ""));
}
}
else
{
if (TreatNullAsZero)
{
dataObject.Environment.Assign(RecordsLength, 0.ToString(), update);
AddDebugOutputItem(new DebugItemWarewolfAtomResult(0.ToString(), RecordsLength, ""));
}
else
{
allErrors.AddError(string.Format(ErrorResource.NullRecordSet, RecordsetName));
}
}
}
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_Two_Scalars_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec]],[[bob]]");
Assert.AreEqual("result field only allows a single result", isSingleValueRule.ErrorText);
}
static void GetValue(IsSingleValueRule isSingleValueRule)
{
//------------Execute Test---------------------------
var err = isSingleValueRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual("The result field only allows a single result", err.Message);
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_TwoIndexes_ExpectErrorNoComma()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingleValueRule);
}
public void IsSingleValueRule_Check_Two_Scalars_ExpectError()
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec]],[[bob]]");
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeValueResultFieldInvalidErrorTest, isSingleValueRule.ErrorText);
}
public void IsSingleValueRule_Check_NoColumSpecifiedStar_ExpectError()
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec(*)]]");
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeValueResultFieldInvalidErrorTest, isSingleValueRule.ErrorText);
}
public void IsSingleValueRule_Check_TwoIndexes_ExpectErrorNoComma()
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingleValueRule);
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_NoColumSpecifiedStar_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec(*)]]");
Assert.AreEqual("result field only allows a single result", isSingleValueRule.ErrorText);
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_TwoIndexes_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]],[[rec().a]]");
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeValueResultFieldInvalidErrorTest, isSingleValueRule.ErrorText);
}
static void GetValue(IsSingleValueRule isSingleValueRule)
{
//------------Execute Test---------------------------
var err = isSingleValueRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeValueResultFieldInvalidErrorTest, err.Message);
}
public void IsSingleValueRule_Check_Scalar_ExpectNull()
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingleValueRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Ctor_Single_Expectmessage_Has_Default()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingleValueRule.Check());
//------------Assert Results-------------------------
}
void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors)
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
AddValidationErrors(allErrors);
if (!allErrors.HasErrors())
{
UpdateEnvironmentAndDebugOutput(dataObject, update, allErrors);
}
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_SingleNested_ExpectNull()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec([[rec().b]]).a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingleValueRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_SingleNested_ExpectNull()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec([[rec().b]]).a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingleValueRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Ctor_Single_Expectmessage_Has_Default()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingleValueRule.Check());
//------------Assert Results-------------------------
}
#pragma warning disable S1541 // Methods and properties should not be too complex
private void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, ErrorResultTO errors)
#pragma warning restore S1541 // Methods and properties should not be too complex
{
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 (!string.IsNullOrEmpty(variableValue))
{
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);
}
}
if (colItr.FieldCount <= 0)
{
var evaluatedValues = new Dictionary <string, string>();
_executionResult = PerformExecution(evaluatedValues);
AssignResult(dataObject, update);
}
else
{
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);
}
_executionResult = PerformExecution(evaluatedValues);
AssignResult(dataObject, update);
}
}
if (dataObject.IsDebugMode() && !allErrors.HasErrors() && !string.IsNullOrWhiteSpace(Result) && dataObject.IsDebugMode() && !allErrors.HasErrors() && !string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
allErrors.MergeErrors(errors);
}
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, FunctionEvaluatorOption.DotNetDateTimeFormat);
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
HandleErrors(dataObject, update, allErrors);
}
}
ErrorResultTO TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors)
{
var rs = DataListUtil.ExtractRecordsetNameFromValue(RecordsetName);
if (RecordsLength == string.Empty)
{
allErrors.AddError(ErrorResource.BlankResultVariable);
}
if (dataObject.IsDebugMode())
{
var warewolfEvalResult = dataObject.Environment.Eval(RecordsetName.Replace("()", "(*)"), update);
if (warewolfEvalResult.IsWarewolfRecordSetResult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfRecordSetResult recsetResult)
{
AddDebugInputItem(new DebugItemWarewolfRecordset(recsetResult.Item, RecordsetName, "Recordset", "="));
}
if (warewolfEvalResult.IsWarewolfAtomListresult && warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult atomListResult)
{
AddDebugInputItem(new DebugEvalResult(RecordsetName, "Recordset", dataObject.Environment, update));
}
}
var rule = new IsSingleValueRule(() => RecordsLength);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
var count = 0;
if (dataObject.Environment.HasRecordSet(RecordsetName))
{
count = dataObject.Environment.GetLength(rs);
}
else
{
allErrors.AddError("Recordset: " + RecordsetName + " does not exist.");
}
var value = count.ToString();
dataObject.Environment.Assign(RecordsLength, value, update);
AddDebugOutputItem(new DebugItemWarewolfAtomResult(value, RecordsLength, ""));
}
return(allErrors);
}
private void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, IExecutionEnvironment env)
{
CleanArgs();
var inputIndex = 1;
var outputIndex = 1;
foreach (var item in ConvertCollection.Where(a => !String.IsNullOrEmpty(a.FromExpression)))
{
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", inputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.FromExpression, "Convert", env, update), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.FromType, "From"), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ToType, "To"), debugItem);
_debugInputs.Add(debugItem);
inputIndex++;
}
try
{
env.ApplyUpdate(item.FromExpression, TryConvertFunc(item, env, update), update);
IsSingleValueRule.ApplyIsSingleValueRule(item.FromExpression, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.FromExpression, "", env, update), debugItem);
_debugOutputs.Add(debugItem);
outputIndex++;
}
}
catch (Exception e)
{
Dev2Logger.Error("DSFBaseConvert", e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
if (dataObject.IsDebugMode())
{
outputIndex++;
}
}
}
}
private void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, ErrorResultTO errors, IExecutionEnvironment env)
{
CleanArgs();
allErrors.MergeErrors(errors);
var inputIndex = 1;
var outputIndex = 1;
foreach (ICaseConvertTO item in ConvertCollection.Where(a => !String.IsNullOrEmpty(a.StringToConvert)))
{
IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", inputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.StringToConvert, "Convert", env, update), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem);
_debugInputs.Add(debugItem);
inputIndex++;
}
if (!allErrors.HasErrors())
{
try
{
env.ApplyUpdate(item.StringToConvert, TryConvertFunc(item, env, update), update);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.StringToConvert, "", env, update), debugItem);
_debugOutputs.Add(debugItem);
outputIndex++;
}
}
}
}
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);
}
}
}
}
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 (RecordsLength == string.Empty)
{
allErrors.AddError(ErrorResource.BlankResultVariable);
}
if (dataObject.IsDebugMode())
{
var warewolfEvalResult = dataObject.Environment.Eval(RecordsetName.Replace("()", "(*)"), update);
if (warewolfEvalResult.IsWarewolfRecordSetResult)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfRecordSetResult;
if (recsetResult != null)
{
AddDebugInputItem(new DebugItemWarewolfRecordset(recsetResult.Item, RecordsetName, "Recordset", "="));
}
}
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (recsetResult != null)
{
AddDebugInputItem(new DebugEvalResult(RecordsetName, "Recordset", dataObject.Environment, update));
}
}
}
var rule = new IsSingleValueRule(() => RecordsLength);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
var count = 0;
if (dataObject.Environment.HasRecordSet(RecordsetName))
{
count = dataObject.Environment.GetLength(rs);
}
else
{
allErrors.AddError("Recordset: " + RecordsetName + " does not exist.");
}
var value = count.ToString();
dataObject.Environment.Assign(RecordsLength, value, update);
AddDebugOutputItem(new DebugItemWarewolfAtomResult(value, RecordsLength, ""));
}
}
catch (Exception e)
{
allErrors.AddError(e.Message);
dataObject.Environment.Assign(RecordsLength, "0", update);
AddDebugOutputItem(new DebugItemStaticDataParams("0", RecordsLength, "", "="));
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfRecordsetLengthActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_NoColumSpecifiedStar_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec(*)]]");
Assert.AreEqual("result field only allows a single result", isSingleValueRule.ErrorText);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_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, update));
AddDebugInputItem(new DebugItemStaticDataParams(ReverseOrder ? "Backward" : "Forward", "Process Direction"));
AddDebugInputItem(new DebugItemStaticDataParams(SkipBlankRows ? "Yes" : "No", "Skip blank rows"));
AddDebug(ResultsCollection, dataObject.Environment, update);
}
var res = new WarewolfIterator(env.Eval(sourceString, update));
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, update == 0 ? 1 : update);
}
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, update);
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, ""), update);
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), update);
}
else if (ExecutionEnvironment.IsScalar(assignVar) && positions[outputVar] == 1)
{
env.AssignWithFrame(new AssignValue(assignVar, tmp), update);
}
else
{
env.AssignWithFrame(new AssignValue(assignVar, tmp), update);
}
positions[outputVar] = positions[outputVar] + 1;
}
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
var outputVarTo = resultsEnumerator.Current.OutputVariable;
AddDebugItem(new DebugEvalResult(outputVarTo, "", env, update), 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, update), debugItem);
_debugOutputs.Add(debugItem);
outputIndex++;
}
}
}
catch (Exception e)
{
Dev2Logger.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, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_TwoIndexes_ExpectErrorNoComma()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingleValueRule);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
var env = dataObject.Environment;
InitializeDebug(dataObject);
try
{
CleanArgs();
allErrors.MergeErrors(errors);
int inputIndex = 1;
int outputIndex = 1;
foreach (ICaseConvertTO item in ConvertCollection.Where(a => !String.IsNullOrEmpty(a.StringToConvert)))
{
IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", inputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.StringToConvert, "Convert", env, update), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem);
_debugInputs.Add(debugItem);
inputIndex++;
}
if (!allErrors.HasErrors())
{
try
{
env.ApplyUpdate(item.StringToConvert, TryConvertFunc(item, env, update), update);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outputIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(item.StringToConvert, "", env, update), debugItem);
_debugOutputs.Add(debugItem);
outputIndex++;
}
}
}
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCaseConvertActivity", 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, int update)
{
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, update));
AddDebugInputItem(new DebugItemStaticDataParams(Index, "Index"));
AddDebugInputItem(new DebugEvalResult(Characters, "Characters", dataObject.Environment, update));
AddDebugInputItem(new DebugItemStaticDataParams(Direction, "Direction"));
}
var itrChar = new WarewolfIterator(dataObject.Environment.Eval(Characters, update));
outerIteratorCollection.AddVariableToIterateOn(itrChar);
var completeResultList = new List <string>();
if (String.IsNullOrEmpty(InField))
{
allErrors.AddError(string.Format(ErrorResource.IsBlank, "'In Field'"));
}
else if (String.IsNullOrEmpty(Characters))
{
allErrors.AddError(string.Format(ErrorResource.IsBlank, "'Characters'"));
}
else
{
while (outerIteratorCollection.HasMoreData())
{
allErrors.MergeErrors(errors);
errors.ClearErrors();
var itrInField = new WarewolfIterator(dataObject.Environment.Eval(InField, update));
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());
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);
}
}
}
completeResultList = new List <string>();
}
}
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
#endregion
}
catch (Exception e)
{
Dev2Logger.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, update));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
static void GetValue(IsSingleValueRule isSingleValueRule)
{
//------------Execute Test---------------------------
var err = isSingleValueRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual("The result field only allows a single result", err.Message);
}
// ReSharper disable InconsistentNaming
public void IsSingleValueRule_Check_Two_Scalars_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingleValueRule = new IsSingleValueRule(() => "[[rec]],[[bob]]");
Assert.AreEqual("result field only allows a single result", isSingleValueRule.ErrorText);
}
/// <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();
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);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(executionId);
}
IFunctionEvaluator functionEvaluator = MathOpsFactory.CreateFunctionEvaluator();
string input = string.IsNullOrEmpty(Expression) ? Expression : Expression.Replace("\\r", string.Empty).Replace("\\n", string.Empty).Replace(Environment.NewLine, "");
IEvaluationFunction evaluationFunctionTo = MathOpsFactory.CreateEvaluationExpressionTO(input);
string result = functionEvaluator.EvaluateFunction(evaluationFunctionTo, executionId, out errors);
allErrors.MergeErrors(errors);
compiler.Upsert(executionId, Result, result, out errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(Result, executionId);
}
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);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(Result, executionId);
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
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, update));
AddDebugInputItem(new DebugItemStaticDataParams(Index, "Index"));
AddDebugInputItem(new DebugEvalResult(Characters, "Characters", dataObject.Environment, update));
AddDebugInputItem(new DebugItemStaticDataParams(Direction, "Direction"));
}
var itrChar = new WarewolfIterator(dataObject.Environment.Eval(Characters, update));
outerIteratorCollection.AddVariableToIterateOn(itrChar);
var completeResultList = new List <string>();
if (String.IsNullOrEmpty(InField))
{
allErrors.AddError("'In Field' is blank");
}
else if (String.IsNullOrEmpty(Characters))
{
allErrors.AddError("'Characters' is blank");
}
else
{
while (outerIteratorCollection.HasMoreData())
{
allErrors.MergeErrors(errors);
errors.ClearErrors();
var itrInField = new WarewolfIterator(dataObject.Environment.Eval(InField, update));
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), update);
allErrors.MergeErrors(errors);
}
else
{
var idx = 1;
foreach (var res in completeResultList)
{
if (rsType == enRecordsetIndexType.Blank)
{
dataObject.Environment.Assign(Result, res, update);
}
if (rsType == enRecordsetIndexType.Star)
{
var expression = DataListUtil.CreateRecordsetDisplayValue(DataListUtil.ExtractRecordsetNameFromValue(Result), DataListUtil.ExtractFieldNameFromValue(Result), idx.ToString());
dataObject.Environment.Assign(DataListUtil.AddBracketsToValueIfNotExist(expression), res, update);
idx++;
}
}
}
}
else
{
dataObject.Environment.Assign(Result, string.Join(",", completeResultList), update);
}
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update));
}
}
}
#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, update));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
#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();
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);
}
}
}
#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, ""));
}
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
dataObject.Environment.Assign(Result, null, update);
DisplayAndWriteError(dataObject, DisplayName, allErrors);
}
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 ErrorResultTO UpdateEnvironment(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, IExecutionEnvironment env, ErrorResultTO errors)
#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
{
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);
}
