void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors) { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); AddValidationErrors(allErrors); if (!allErrors.HasErrors()) { UpdateEnvironmentAndDebugOutput(dataObject, update, allErrors); } }
#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); } }
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++; } } } }
/// <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); } } }
private void TryExecute(IDSFDataObject dataObject, int update, ErrorResultTO allErrors) { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); if (dataObject.IsDebugMode()) { if (string.IsNullOrEmpty(DateTime)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time", "Input"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(System.DateTime.Now.ToString(CultureInfo.CurrentCulture), "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(DateTime, "Input", dataObject.Environment, update)); } var cultureType = typeof(CultureInfo); var fieldInfo = cultureType.GetField("s_userDefaultCulture", BindingFlags.NonPublic | BindingFlags.Static); if (fieldInfo != null) { var val = fieldInfo.GetValue(CultureInfo.CurrentCulture); var newCul = val as CultureInfo; if (newCul != null) { Thread.CurrentThread.CurrentCulture = newCul; } } var dateTimePattern = string.Format("{0} {1}", Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern, Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongTimePattern); if (string.IsNullOrEmpty(InputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Input Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(InputFormat, "Input Format", dataObject.Environment, update)); } var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams(TimeModifierType, "Add Time"), debugItem); AddDebugItem(new DebugEvalResult(TimeModifierAmountDisplay, "", dataObject.Environment, update), debugItem); _debugInputs.Add(debugItem); if (string.IsNullOrEmpty(OutputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Output Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(OutputFormat, "Output Format", dataObject.Environment, update)); } } if (DataListUtil.HasNegativeIndex(InputFormat)) { allErrors.AddError(string.Format("Negative Recordset Index for Input Format: {0}", InputFormat)); } if (DataListUtil.HasNegativeIndex(OutputFormat)) { allErrors.AddError(string.Format("Negative Recordset Index for Output Format: {0}", OutputFormat)); } if (DataListUtil.HasNegativeIndex(TimeModifierAmountDisplay)) { allErrors.AddError(string.Format("Negative Recordset Index for Add Time: {0}", TimeModifierAmountDisplay)); } if (!allErrors.HasErrors()) { UpdateDatalist(dataObject, update, allErrors); } }
// ReSharper restore RedundantOverridenMember /// <summary> /// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity /// </summary> protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); _indexCounter = 0; IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors; Guid executionId = DataListExecutionID.Get(context); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false); InitializeDebug(dataObject); try { CleanArgs(); toUpsert.IsDebug = dataObject.IsDebugMode(); foreach (var item in ConvertCollection) { try { _indexCounter++; // Travis.Frisinger - This needs to be in the ViewModel not here ;) if (item.ToExpression == string.Empty) { item.ToExpression = item.FromExpression; } IsSingleValueRule.ApplyIsSingleValueRule(item.FromExpression, allErrors); var fieldName = item.FromExpression; fieldName = DataListUtil.IsValueRecordset(fieldName) ? DataListUtil.ReplaceRecordsetIndexWithBlank(fieldName) : fieldName; var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), Dev2.DataList.Contract.enTranslationDepth.Shape, out errors); if (!datalist.IsNullOrEmpty()) { var isValidExpr = new IsValidExpressionRule(() => fieldName, datalist.ToString()) { LabelText = fieldName }; var errorInfo = isValidExpr.Check(); if (errorInfo != null) { item.FromExpression = ""; errors.AddError(errorInfo.Message); } allErrors.MergeErrors(errors); } IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.FromExpression, false, out errors); if (dataObject.IsDebugMode()) { AddDebugInputItem(item.FromExpression, tmp, executionId, item.FromType, item.ToType); } allErrors.MergeErrors(errors); if (tmp != null) { IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp); IBaseConverter from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType))); IBaseConverter to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType))); IBaseConversionBroker broker = _fac.CreateBroker(from, to); // process result information while (itr.HasMoreRecords()) { IList <IBinaryDataListItem> cols = itr.FetchNextRowData(); foreach (IBinaryDataListItem c in cols) { // set up live flushing iterator details if (c.IsDeferredRead) { if (toUpsert != null) { toUpsert.HasLiveFlushing = true; toUpsert.LiveFlushingLocation = executionId; } } int indexToUpsertTo = c.ItemCollectionIndex; string val = string.IsNullOrEmpty(c.TheValue) ? "" : broker.Convert(c.TheValue); string expression = item.ToExpression; if (DataListUtil.IsValueRecordset(item.ToExpression) && DataListUtil.GetRecordsetIndexType(item.ToExpression) == enRecordsetIndexType.Star) { expression = item.ToExpression.Replace(GlobalConstants.StarExpression, indexToUpsertTo.ToString(CultureInfo.InvariantCulture)); } toUpsert.Add(expression, val); if (toUpsert != null && toUpsert.HasLiveFlushing) { toUpsert.FlushIterationFrame(); toUpsert = null; } } } } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } finally { if (allErrors.HasErrors()) { toUpsert.Add(item.ToExpression, null); } } } if (toUpsert != null && toUpsert.HasLiveFlushing) { try { toUpsert.FlushIterationFrame(); } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } } else { compiler.Upsert(executionId, toUpsert, out errors); allErrors.MergeErrors(errors); } if (!allErrors.HasErrors() && toUpsert != null) { var outIndex = 1; foreach (var debugOutputTo in toUpsert.DebugOutputs) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem); _debugOutputs.Add(debugItem); outIndex++; } } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfBaseConvertActivity", allErrors); compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors); } if (dataObject.IsDebugMode()) { DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
// ReSharper restore RedundantOverridenMember /// <summary> /// Executes the logic of the activity and calls the backend code to do the work /// Also responsible for adding the results to the data list /// </summary> /// <param name="context"></param> protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); ErrorResultTO errors; ErrorResultTO allErrors = new ErrorResultTO(); Guid executionId = dataObject.DataListID; InitializeDebug(dataObject); try { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); // Fetch all fields to search.... IList <string> toSearch = FieldsToSearch.Split(','); // now process each field for entire evaluated Where expression.... IBinaryDataListEntry bdle = compiler.Evaluate(executionId, enActionType.User, SearchCriteria, false, out errors); if (dataObject.IsDebugMode()) { var itemToAdd = new DebugItem(); itemToAdd.Add(new DebugItemResult { Type = DebugItemResultType.Label, Value = "Fields To Search" }); _debugInputs.Add(itemToAdd); } allErrors.MergeErrors(errors); if (bdle != null) { IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(bdle); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); int idx; if (!Int32.TryParse(StartIndex, out idx)) { idx = 1; } IBinaryDataList toSearchList = compiler.FetchBinaryDataList(executionId, out errors); allErrors.MergeErrors(errors); int iterationIndex = 0; foreach (string s in toSearch) { if (dataObject.IsDebugMode()) { IBinaryDataListEntry tmpEntry = compiler.Evaluate(executionId, enActionType.User, s, false, out errors); AddDebugInputItem(s, string.Empty, tmpEntry, executionId); } // each entry in the recordset while (itr.HasMoreRecords()) { IList <IBinaryDataListItem> cols = itr.FetchNextRowData(); foreach (IBinaryDataListItem c in cols) { IRecsetSearch searchTo = ConvertToSearchTo(c.TheValue, idx.ToString(CultureInfo.InvariantCulture)); IList <string> results = RecordsetInterrogator.FindRecords(toSearchList, searchTo, out errors); allErrors.MergeErrors(errors); string concatRes = string.Empty; // ReSharper disable LoopCanBeConvertedToQuery foreach (string r in results) // ReSharper restore LoopCanBeConvertedToQuery { concatRes = string.Concat(concatRes, r, ","); } if (concatRes.EndsWith(",")) { concatRes = concatRes.Remove(concatRes.Length - 1); } //2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result DataListCleaningUtils.SplitIntoRegions(Result); //2013.06.07: Massimo Guerrera for BUG 9497 - To handle putting out to a scalar as a CSV if (!DataListUtil.IsValueRecordset(Result)) { toUpsert.Add(Result, concatRes); toUpsert.FlushIterationFrame(); if (dataObject.IsDebugMode()) { AddDebugOutputItem(new DebugOutputParams(Result, concatRes, executionId, iterationIndex)); } } else { iterationIndex = 0; foreach (string r in results) { toUpsert.Add(Result, r); toUpsert.FlushIterationFrame(); if (dataObject.IsDebugMode()) { AddDebugOutputItem(new DebugOutputParams(Result, r, executionId, iterationIndex)); } iterationIndex++; } } } } } if (dataObject.IsDebugMode()) { AddDebugInputItem(SearchCriteria, "Where", bdle, executionId); } // now push the result to the server compiler.Upsert(executionId, toUpsert, out errors); allErrors.MergeErrors(errors); } } finally { var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfFindRecordsActivity", 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(new DebugItemStaticDataParams("", Result, "")); } DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
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 restore RedundantOverridenMember /// <summary> /// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity /// </summary> protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); toUpsert.IsDebug = dataObject.IsDebugMode(); toUpsert.ReplaceStarWithFixedIndex = true; ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors = new ErrorResultTO(); Guid executionId = DataListExecutionID.Get(context); InitializeDebug(dataObject); try { CleanArgs(); ICaseConverter converter = CaseConverterFactory.CreateCaseConverter(); allErrors.MergeErrors(errors); int index = 1; int outIndex = 0; foreach (ICaseConvertTO item in ConvertCollection) { outIndex++; IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors); allErrors.MergeErrors(errors); ValidateVariable(item.Result, compiler, dataObject, out errors); allErrors.MergeErrors(errors); IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors); if (dataObject.IsDebugMode()) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", index.ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(item.StringToConvert, "Convert", tmp, executionId), debugItem); AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem); _debugInputs.Add(debugItem); index++; } if (tmp != null) { IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp); while (itr.HasMoreRecords()) { foreach (IBinaryDataListItem itm in itr.FetchNextRowData()) { try { IBinaryDataListItem res = converter.TryConvert(item.ConvertType, itm); string expression = item.Result; // 27.08.2013 // NOTE : The result must remain [ as this is how the fliping studio generates the result when using (*) notation // There is a proper bug in to fix this issue, but since the studio is spaghetti I will leave this to the experts ;) // This is a tmp fix to the issue if (expression == "[" || DataListUtil.GetRecordsetIndexType(expression) == enRecordsetIndexType.Star) { expression = DataListUtil.AddBracketsToValueIfNotExist(res.DisplayValue); } //2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result IsSingleValueRule rule = new IsSingleValueRule(() => expression); var singleresError = rule.Check(); if (singleresError != null) { allErrors.AddError(singleresError.Message); } else { toUpsert.Add(expression, res.TheValue); // Upsert the entire payload } allErrors.MergeErrors(errors); } catch (Exception e) { allErrors.AddError(e.Message); toUpsert.Add(item.Result, null); } } } compiler.Upsert(executionId, toUpsert, out errors); if (!allErrors.HasErrors() && dataObject.IsDebugMode()) { foreach (var debugOutputTo in toUpsert.DebugOutputs) { var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem); _debugOutputs.Add(debugItem); } toUpsert.DebugOutputs.Clear(); } } } } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfCaseConvertActivity", allErrors); compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors); } if (dataObject.IsDebugMode()) { if (hasErrors) { int outIndex = 1; foreach (ICaseConvertTO item in ConvertCollection) { IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors); var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem); AddDebugItem(new DebugItemVariableParams(item.Result, "", tmp, executionId), debugItem); _debugOutputs.Add(debugItem); outIndex++; } } DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
protected override void ExecuteTool(IDSFDataObject dataObject) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); ErrorResultTO allErrors = new ErrorResultTO(); InitializeDebug(dataObject); // Process if no errors try { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); if (dataObject.IsDebugMode()) { if (string.IsNullOrEmpty(DateTime)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time", "Input"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(System.DateTime.Now.ToString(CultureInfo.CurrentCulture), "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(DateTime, "Input", dataObject.Environment)); } var cultureType = typeof(CultureInfo); var fieldInfo = cultureType.GetField("s_userDefaultCulture", BindingFlags.NonPublic | BindingFlags.Static); if (fieldInfo != null) { var val = fieldInfo.GetValue(CultureInfo.CurrentCulture); var newCul = val as CultureInfo; if (newCul != null) { Thread.CurrentThread.CurrentCulture = newCul; } } var dateTimePattern = string.Format("{0} {1}", Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern, Thread.CurrentThread.CurrentCulture.DateTimeFormat.LongTimePattern); if (string.IsNullOrEmpty(InputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Input Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(InputFormat, "Input Format", dataObject.Environment)); } var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams(TimeModifierType, "Add Time"), debugItem); AddDebugItem(new DebugEvalResult(TimeModifierAmountDisplay, "", dataObject.Environment), debugItem); _debugInputs.Add(debugItem); if (string.IsNullOrEmpty(OutputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Output Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugEvalResult(OutputFormat, "Output Format", dataObject.Environment)); } } if (DataListUtil.HasNegativeIndex(InputFormat)) { allErrors.AddError(string.Format("Negative Recordset Index for Input Format: {0}", InputFormat)); } if (DataListUtil.HasNegativeIndex(OutputFormat)) { allErrors.AddError(string.Format("Negative Recordset Index for Output Format: {0}", OutputFormat)); } if (DataListUtil.HasNegativeIndex(TimeModifierAmountDisplay)) { allErrors.AddError(string.Format("Negative Recordset Index for Add Time: {0}", TimeModifierAmountDisplay)); } if (!allErrors.HasErrors()) { var colItr = new WarewolfListIterator(); var dtItr = CreateDataListEvaluateIterator(string.IsNullOrEmpty(DateTime) ? GlobalConstants.CalcExpressionNow : DateTime, dataObject.Environment); colItr.AddVariableToIterateOn(dtItr); var ifItr = CreateDataListEvaluateIterator(InputFormat, dataObject.Environment); colItr.AddVariableToIterateOn(ifItr); var ofItr = CreateDataListEvaluateIterator(OutputFormat, dataObject.Environment); colItr.AddVariableToIterateOn(ofItr); var tmaItr = CreateDataListEvaluateIterator(TimeModifierAmountDisplay, dataObject.Environment); colItr.AddVariableToIterateOn(tmaItr); if (!allErrors.HasErrors()) { while (colItr.HasMoreData()) { IDateTimeOperationTO transObj = ConvertToDateTimeTo(colItr.FetchNextValue(dtItr), colItr.FetchNextValue(ifItr), colItr.FetchNextValue(ofItr), TimeModifierType, colItr.FetchNextValue(tmaItr) ); IDateTimeFormatter format = DateTimeConverterFactory.CreateFormatter(); string result; string error; if (format.TryFormat(transObj, out result, out error)) { string expression = Result; dataObject.Environment.Assign(expression, result); } else { allErrors.AddError(error); } } if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment)); } } } } catch (Exception e) { Dev2Logger.Log.Error("DSFDateTime", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfDateTimeActivity", allErrors); var errorString = allErrors.MakeDisplayReady(); dataObject.Environment.AddError(errorString); } if (dataObject.IsDebugMode()) { if (hasErrors) { AddDebugOutputItem(new DebugItemStaticDataParams("", Result, "")); } DispatchDebugState(dataObject, StateType.Before); DispatchDebugState(dataObject, StateType.After); } } }
// ReSharper restore RedundantOverridenMember protected override void OnExecute(NativeActivityContext context) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); _indexCounter = 1; IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>(); IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); Guid dlId = dataObject.DataListID; ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors; _datalistString = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), Dev2.DataList.Contract.enTranslationDepth.Shape, out errors).ToString(); InitializeDebug(dataObject); try { var sourceString = SourceString ?? ""; IBinaryDataListEntry expressionsEntry = compiler.Evaluate(dlId, enActionType.User, sourceString, false, out errors); if (dataObject.IsDebugMode()) { AddDebugInputItem(new DebugItemVariableParams(sourceString, "String to Split", expressionsEntry, dlId)); AddDebugInputItem(new DebugItemStaticDataParams(ReverseOrder ? "Backward" : "Forward", "Process Direction")); AddDebugInputItem(new DebugItemStaticDataParams(SkipBlankRows ? "Yes" : "No", "Skip blank rows")); } CleanArguments(ResultsCollection); ResultsCollection.ToList().ForEach(a => IsSingleValueRule.ApplyIsSingleValueRule(a.OutputVariable, allErrors)); if (ResultsCollection.Count > 0) { if (dataObject.IsDebugMode()) { AddDebug(ResultsCollection, compiler, dlId); } CheckIndex(sourceString); allErrors.MergeErrors(errors); IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntry); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); bool singleInnerIteration = ArePureScalarTargets(ResultsCollection); bool exit = false; while (itr.HasMoreRecords()) { IList <IBinaryDataListItem> cols = itr.FetchNextRowData(); foreach (IBinaryDataListItem c in cols) { // set up live flushing iterator details toUpsert.HasLiveFlushing = true; toUpsert.LiveFlushingLocation = dlId; #pragma warning disable 219 int opCnt = 0; #pragma warning restore 219 if (!string.IsNullOrEmpty(c.TheValue)) { string val = c.TheValue; 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); } } } IDev2Tokenizer tokenizer = CreateSplitPattern(ref val, ResultsCollection, compiler, dlId, 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 ;) HashSet <string> usedTokens = new HashSet <string>(); while (tokenizer.HasMoreOps() && !exit) { string tmp = tokenizer.NextToken(); if (blankRows.Contains(opCnt) && blankRows.Count != 0) { tmp = tmp.Replace(Environment.NewLine, ""); while (pos != end + 1) { UpdateOutputVariableWithValue(pos, usedTokens, toUpsert, ""); pos++; } pos = CompletedRow(usedTokens, toUpsert, singleInnerIteration, ref opCnt, ref exit); } UpdateOutputVariableWithValue(pos, usedTokens, toUpsert, tmp); // Per pass if (pos == end) { //row has been processed pos = CompletedRow(usedTokens, toUpsert, singleInnerIteration, ref opCnt, ref exit); } else { pos++; } } // flush the final frame ;) toUpsert.FlushIterationFrame(); toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); } } } } } if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { AddResultToDebug(compiler, dlId); } } } catch (Exception e) { Dev2Logger.Log.Error("DSFDataSplit", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfDataSplitActivity", allErrors); compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors); } if (dataObject.IsDebugMode()) { if (hasErrors) { AddResultToDebug(compiler, dlId); } DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }
protected override void ExecuteTool(IDSFDataObject dataObject, int update) { ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors = new ErrorResultTO(); allErrors.MergeErrors(errors); InitializeDebug(dataObject); try { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); if (dataObject.IsDebugMode()) { AddDebugInputItem(dataObject.Environment, update); } 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, update); 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, update); } if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { AddDebugOutputItem(Result, dataObject.Environment, update); } 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, 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); } } }
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) { ErrorResultTO allErrors = new ErrorResultTO(); ErrorResultTO errors = new ErrorResultTO(); //Guid executionId = DataListExecutionID.Get(context); allErrors.MergeErrors(errors); InitializeDebug(dataObject); // Process if no errors try { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); var colItr = new WarewolfListIterator(); var iteratorPropertyDictionary = new Dictionary <string, IWarewolfIterator>(); foreach (var propertyInfo in GetType().GetProperties().Where(info => info.IsDefined(typeof(Inputs)))) { var attributes = (Inputs[])propertyInfo.GetCustomAttributes(typeof(Inputs), false); var variableValue = propertyInfo.GetValue(this) as string; if (dataObject.IsDebugMode()) { AddDebugInputItem(new DebugEvalResult(variableValue, attributes[0].UserVisibleName, dataObject.Environment, update)); } var dtItr = CreateDataListEvaluateIterator(variableValue, dataObject.Environment, update); colItr.AddVariableToIterateOn(dtItr); iteratorPropertyDictionary.Add(propertyInfo.Name, dtItr); } while (colItr.HasMoreData()) { var evaluatedValues = new Dictionary <string, string>(); foreach (var dev2DataListEvaluateIterator in iteratorPropertyDictionary) { var binaryDataListItem = colItr.FetchNextValue(dev2DataListEvaluateIterator.Value); evaluatedValues.Add(dev2DataListEvaluateIterator.Key, binaryDataListItem); } var result = PerformExecution(evaluatedValues); dataObject.Environment.Assign(Result, result, update); } allErrors.MergeErrors(errors); if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment, update)); } } allErrors.MergeErrors(errors); } catch (Exception ex) { Dev2Logger.Log.Error(string.Format("{0} Exception", DisplayName), ex); allErrors.AddError(ex.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError(DisplayName, allErrors); var errorList = allErrors.MakeDataListReady(); dataObject.Environment.AddError(errorList); dataObject.Environment.Assign(Result, null, update); } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before, update); DispatchDebugState(dataObject, StateType.After, update); } } }
protected override void ExecuteTool(IDSFDataObject dataObject) { _debugInputs = new List <DebugItem>(); _debugOutputs = new List <DebugItem>(); ErrorResultTO allErrors = new ErrorResultTO(); InitializeDebug(dataObject); var env = dataObject.Environment; try { CleanArgs(); int inputIndex = 1; int 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), 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)); 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), debugItem); _debugOutputs.Add(debugItem); outputIndex++; } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); if (dataObject.IsDebugMode()) { //var debugItem = new DebugItem(); // AddDebugItem(new DebugItemStaticDataParams("", outputIndex.ToString(CultureInfo.InvariantCulture)), debugItem); // AddDebugItem(new DebugEvalResult(item.FromExpression, "", env), debugItem); // _debugOutputs.Add(debugItem); outputIndex++; } } } } catch (Exception e) { Dev2Logger.Log.Error("DSFBaseConvert", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfBaseConvertActivity", allErrors); var errorString = allErrors.MakeDisplayReady(); dataObject.Environment.AddError(errorString); } if (dataObject.IsDebugMode()) { DispatchDebugState(dataObject, StateType.Before); DispatchDebugState(dataObject, StateType.After); } } }
/// <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; Guid executionId = DataListExecutionID.Get(context); InitializeDebug(dataObject); // Process if no errors try { IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors); IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true); toUpsert.IsDebug = (dataObject.IsDebugMode()); toUpsert.ResourceID = dataObject.ResourceID; IDev2IteratorCollection colItr = Dev2ValueObjectFactory.CreateIteratorCollection(); IDev2DataListEvaluateIterator dtItr = CreateDataListEvaluateIterator(string.IsNullOrEmpty(DateTime) ? GlobalConstants.CalcExpressionNow : DateTime, executionId, compiler, colItr, allErrors); colItr.AddIterator(dtItr); IDev2DataListEvaluateIterator ifItr = CreateDataListEvaluateIterator(InputFormat, executionId, compiler, colItr, allErrors); colItr.AddIterator(ifItr); IDev2DataListEvaluateIterator ofItr = CreateDataListEvaluateIterator(OutputFormat, executionId, compiler, colItr, allErrors); colItr.AddIterator(ofItr); IDev2DataListEvaluateIterator tmaItr = CreateDataListEvaluateIterator(TimeModifierAmountDisplay, executionId, compiler, colItr, allErrors); colItr.AddIterator(tmaItr); if (dataObject.IsDebugMode()) { if (string.IsNullOrEmpty(DateTime)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time", "Input"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(System.DateTime.Now.ToString(CultureInfo.CurrentCulture), "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugItemVariableParams(DateTime, "Input", dtItr.FetchEntry(), executionId)); } var dateTimePattern = string.Format("{0} {1}", CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern, CultureInfo.CurrentCulture.DateTimeFormat.LongTimePattern); if (string.IsNullOrEmpty(InputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Input Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugItemVariableParams(InputFormat, "Input Format", ifItr.FetchEntry(), executionId)); } var debugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams(TimeModifierType, "Add Time"), debugItem); AddDebugItem(new DebugItemVariableParams(TimeModifierAmountDisplay, "", tmaItr.FetchEntry(), executionId, true), debugItem); _debugInputs.Add(debugItem); if (string.IsNullOrEmpty(OutputFormat)) { var defaultDateTimeDebugItem = new DebugItem(); AddDebugItem(new DebugItemStaticDataParams("System Date Time Format", "Output Format"), defaultDateTimeDebugItem); AddDebugItem(new DebugItemStaticDataParams(dateTimePattern, "="), defaultDateTimeDebugItem); _debugInputs.Add(defaultDateTimeDebugItem); } else { AddDebugInputItem(new DebugItemVariableParams(OutputFormat, "Output Format", ofItr.FetchEntry(), executionId)); } } if (!allErrors.HasErrors()) { while (colItr.HasMoreData()) { IDateTimeOperationTO transObj = ConvertToDateTimeTo(colItr.FetchNextRow(dtItr).TheValue, colItr.FetchNextRow(ifItr).TheValue, colItr.FetchNextRow(ofItr).TheValue, TimeModifierType, colItr.FetchNextRow(tmaItr).TheValue ); //Create a DateTimeFomatter using the DateTimeConverterFactory.DONE IDateTimeFormatter format = DateTimeConverterFactory.CreateFormatter(); string result; string error; if (format.TryFormat(transObj, out result, out error)) { string expression = Result; //2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result toUpsert.Add(expression, result); toUpsert.FlushIterationFrame(); } else { allErrors.AddError(error); } } compiler.Upsert(executionId, toUpsert, out errors); allErrors.MergeErrors(errors); if (dataObject.IsDebugMode() && !allErrors.HasErrors()) { foreach (var debugOutputTo in toUpsert.DebugOutputs) { AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo)); } } allErrors.MergeErrors(errors); } } catch (Exception e) { Dev2Logger.Log.Error("DSFDateTime", e); allErrors.AddError(e.Message); } finally { // Handle Errors var hasErrors = allErrors.HasErrors(); if (hasErrors) { DisplayAndWriteError("DsfDateTimeActivity", 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(new DebugItemStaticDataParams("", Result, "")); } DispatchDebugState(context, StateType.Before); DispatchDebugState(context, StateType.After); } } }