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------------------------- }
#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); } } }
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); } } }
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); } } }
/// <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); }