public void UpsertBuilder_AssignStyleAppend_Expect_10RecordSetEntries_And_Scalar()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
string error;
tmp.Add("[[scalar]]", "myScalar");
tmp.FlushIterationFrame();
tmp.Add("[[recset().f1]]", "field1_value1a");
tmp.Add("[[recset().f2]]", "field2_value1a");
tmp.FlushIterationFrame();
tmp.Add("[[recset(10).f1]]", "field1_value2a");
tmp.Add("[[recset(10).f2]]", "field2_value2a");
ErrorResultTO errors;
Guid id = _compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), _adlData.ToStringBuilder(), new StringBuilder(_dlShape), out errors);
_compiler.Upsert(id, tmp, out errors);
IBinaryDataList bdl = _compiler.FetchBinaryDataList(id, out errors);
// Else we good to go, normal asserts ;)
IBinaryDataListEntry recset;
bdl.TryGetEntry("recset", out recset, out error);
IBinaryDataListEntry scalar;
bdl.TryGetEntry("scalar", out scalar, out error);
var res1 = scalar.FetchScalar().TheValue;
var res2 = recset.FetchLastRecordsetIndex();
// we have a single scalar
Assert.AreEqual("myScalar", res1);
Assert.AreEqual(10, res2);
}
public void UpsertBuilder_AssignStyleAppend_Expect_Scalar_WithLastRecord()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
tmp.Add("[[recset().f1]]", "field1_value1a");
tmp.Add("[[recset().f2]]", "field2_value1a");
tmp.FlushIterationFrame();
tmp.Add("[[scalar]]", "[[recset(*).f1]]");
tmp.FlushIterationFrame();
ErrorResultTO errors;
Guid id = _compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), _adlData.ToStringBuilder(), new StringBuilder(_dlShape), out errors);
_compiler.Upsert(id, tmp, out errors);
IBinaryDataList bdl = _compiler.FetchBinaryDataList(id, out errors);
IBinaryDataListEntry scalar;
string error;
bdl.TryGetEntry("scalar", out scalar, out error);
var res = scalar.FetchScalar().TheValue;
// we have a single scalar
Assert.AreEqual("field1_value1a", res);
}
public void TryFetchLastIndexedRecordsetUpsertPayload_ColumnName_FetchesForColumn()
{
//------------Setup for test--------------------------
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();
toUpsert.Add("[[rec().f1]]", new List <string> {
"test11", "test12"
});
toUpsert.Add("[[rec().f2]]", new List <string> {
"test21", "test22"
});
IBinaryDataList dataList = Dev2BinaryDataListFactory.CreateDataList();
string creationError;
dataList.TryCreateRecordsetTemplate("rec", "recset", new List <Dev2Column> {
DataListFactory.CreateDev2Column("f1", "f1"), DataListFactory.CreateDev2Column("f2", "f2")
}, true, out creationError);
ErrorResultTO localErrors;
compiler.PushBinaryDataList(dataList.UID, dataList, out localErrors);
compiler.Upsert(dataList.UID, toUpsert, out _errors);
IBinaryDataListEntry recEntry;
string error;
dataList.TryGetEntry("rec", out recEntry, out error);
//------------Assert Preconditions-------------------
Assert.IsNotNull(recEntry);
//------------Execute Test---------------------------
var listItem = recEntry.TryFetchLastIndexedRecordsetUpsertPayload(out error, "f2");
//------------Assert Results-------------------------
Assert.AreEqual("test22", listItem.TheValue);
}
void UpdateResultRegions(string expression, IDev2DataListUpsertPayloadBuilder <string> toUpsert, string result)
{
foreach (var region in DataListCleaningUtils.SplitIntoRegions(expression))
{
toUpsert.Add(region, result);
toUpsert.FlushIterationFrame();
}
}
public void UpsertPayloadBuilder_Without_Flush_Valid_Entries()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
tmp.Add("[[scalar]]", "zzz");
tmp.Add("[[scalar2]]", "aaa");
Assert.AreEqual(1, tmp.FetchFrames().Count);
}
public void UpsertPayloadBuilder_MultFrames_Expect_Valid_Entries()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
tmp.Add("[[scalar]]", "zzz");
tmp.FlushIterationFrame();
tmp.Add("[[scalar2]]", "aaa");
Assert.AreEqual(2, tmp.FetchFrames().Count);
}
void PushResultsToDataList(string expression, IDev2DataListUpsertPayloadBuilder <string> toUpsert, string result, IDSFDataObject dataObject, Guid executionId, IDataListCompiler compiler, ErrorResultTO allErrors)
{
UpdateResultRegions(expression, toUpsert, result);
compiler.Upsert(executionId, toUpsert, out errorsTo);
if (dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
allErrors.MergeErrors(errorsTo);
}
static int CompletedRow(HashSet <string> usedTokens, IDev2DataListUpsertPayloadBuilder <string> toUpsert, bool singleInnerIteration, ref int opCnt, ref bool exit)
{
opCnt++;
// clear token cache
usedTokens.Clear();
toUpsert.FlushIterationFrame();
if (singleInnerIteration)
{
exit = true;
}
return(0);
}
public void UpsertBuilder_AssignStyleAppend_Expect_2RecordSetEntries_And_Scalar_AsDebug()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
tmp.IsDebug = true;
tmp.Add("[[scalar]]", "myScalar");
tmp.FlushIterationFrame();
tmp.Add("[[recset().f1]]", "field1_value1");
tmp.Add("[[recset().f2]]", "field2_value1");
tmp.FlushIterationFrame();
tmp.Add("[[recset().f1]]", "field1_value2");
tmp.Add("[[recset().f2]]", "field2_value2");
ErrorResultTO errors;
Guid id = _compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), string.Empty.ToStringBuilder(), new StringBuilder(_dlShape), out errors);
_compiler.Upsert(id, tmp, out errors);
IBinaryDataList bdl = _compiler.FetchBinaryDataList(id, out errors);
// Else we good to go, normal asserts ;)
IBinaryDataListEntry recset;
string error;
bdl.TryGetEntry("recset", out recset, out error);
IBinaryDataListEntry scalar;
bdl.TryGetEntry("scalar", out scalar, out error);
var res1 = scalar.FetchScalar().TheValue;
var res2 = recset.FetchLastRecordsetIndex();
// we have a single scalar
Assert.AreEqual("myScalar", res1);
Assert.AreEqual(2, res2);
Assert.IsNotNull(tmp.DebugOutputs);
Assert.IsNotNull(tmp.DebugOutputs[0].LeftEntry);
Assert.IsNotNull(tmp.DebugOutputs[0].RightEntry);
Assert.IsNotNull(tmp.DebugOutputs[0].TargetEntry);
Assert.IsNotNull(tmp.DebugOutputs[0].RightEntry.ComplexExpressionAuditor);
Assert.IsNotNull(tmp.DebugOutputs[0].LeftEntry.ComplexExpressionAuditor);
Assert.IsNotNull(tmp.DebugOutputs[0].TargetEntry.ComplexExpressionAuditor);
Assert.AreEqual(1, tmp.DebugOutputs[0].RightEntry.ComplexExpressionAuditor.FetchAuditItems().Count);
Assert.AreEqual(1, tmp.DebugOutputs[0].LeftEntry.ComplexExpressionAuditor.FetchAuditItems().Count);
Assert.AreEqual(5, tmp.DebugOutputs[0].TargetEntry.ComplexExpressionAuditor.FetchAuditItems().Count);
}
public void Replace_CaseMatch_Recorset_Expected_No_Replaces()
{
ErrorResultTO errors;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid exidx = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), TestStrings.ReplaceDataListWithData, TestStrings.ReplaceDataListShape.ToStringBuilder(), out errors);
IDev2DataListUpsertPayloadBuilder <string> payloadBuilder = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
IBinaryDataListEntry entry;
IDev2ReplaceOperation replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
const string Expression = "[[results(*).resfield]]";
int replaceCount;
// ReSharper disable RedundantAssignment
payloadBuilder = replaceOperation.Replace(exidx, Expression, "hello", "World", true, payloadBuilder, out errors, out replaceCount, out entry);
// ReSharper restore RedundantAssignment
Assert.AreEqual(0, replaceCount);
}
public void Dev2DataListUpsertPayloadBuilder_UnitTest_KeepsStarIndexingWhenNotReplacing()
{
IDev2DataListUpsertPayloadBuilder <string> builder = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
builder.Add("[[rs(*).val]]", "aaa");
builder.FlushIterationFrame();
builder.Add("[[rs(*).val]]", "aaa");
var items = builder.FetchFrames(true);
foreach (var itm in items)
{
var exp = itm.FetchNextFrameItem().Expression;
const string Expected = "rs(*).val";
StringAssert.Contains(exp, Expected, "Index substitution occurred when not active");
}
}
public void UpsertWhereListStringExpectUpsertCorrectlyMultipleRecordset()
{
//------------Setup for test--------------------------
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();
toUpsert.Add("[[rec().f1]]", new List <string> {
"test11", "test12"
});
toUpsert.Add("[[rec().f2]]", new List <string> {
"test21", "test22"
});
IBinaryDataList dataList = Dev2BinaryDataListFactory.CreateDataList();
string creationError;
dataList.TryCreateRecordsetTemplate("rec", "recset", new List <Dev2Column> {
DataListFactory.CreateDev2Column("f1", "f1"), DataListFactory.CreateDev2Column("f2", "f2")
}, true, out creationError);
ErrorResultTO localErrors;
compiler.PushBinaryDataList(dataList.UID, dataList, out localErrors);
//------------Execute Test---------------------------
compiler.Upsert(dataList.UID, toUpsert, out _errors);
//------------Assert Results-------------------------
IList <IBinaryDataListEntry> binaryDataListEntries = dataList.FetchRecordsetEntries();
IBinaryDataListEntry binaryDataListEntry = binaryDataListEntries[0];
string errString;
IList <IBinaryDataListItem> binaryDataListItems = binaryDataListEntry.FetchRecordAt(1, out errString);
IBinaryDataListItem binaryDataListItem = binaryDataListItems[0];
IBinaryDataListItem binaryDataListItem2 = binaryDataListItems[1];
string theValue = binaryDataListItem.TheValue;
Assert.AreEqual("test11", theValue);
theValue = binaryDataListItem2.TheValue;
Assert.AreEqual("test21", theValue);
binaryDataListItems = binaryDataListEntry.FetchRecordAt(2, out errString);
binaryDataListItem = binaryDataListItems[0];
binaryDataListItem2 = binaryDataListItems[1];
theValue = binaryDataListItem.TheValue;
Assert.AreEqual("test12", theValue);
theValue = binaryDataListItem2.TheValue;
Assert.AreEqual("test22", theValue);
}
void UpdateOutputVariableWithValue(int pos, HashSet <string> usedTokens, IDev2DataListUpsertPayloadBuilder <string> toUpsert, string tmp)
{
var dataSplitDto = ResultsCollection[pos];
var outputVariable = dataSplitDto.OutputVariable;
CheckIndex(outputVariable);
CheckIndex(dataSplitDto.EscapeChar);
if (!string.IsNullOrEmpty(outputVariable))
{
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
// if it already exist, flush this round ;)
if (!usedTokens.Add(outputVariable))
{
toUpsert.FlushIterationFrame();
}
toUpsert.Add(outputVariable, tmp);
}
}
public void Replace_NoCaseMatch_Recorset_Expected_Correct_Data_Returned_ReplaceCount_Twenty()
{
ErrorResultTO errors;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid exidx = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), TestStrings.ReplaceDataListWithData.ToStringBuilder(), TestStrings.ReplaceDataListShape.ToStringBuilder(), out errors);
IDev2DataListUpsertPayloadBuilder <string> payloadBuilder = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
IDev2ReplaceOperation replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
IBinaryDataListEntry entry;
const string Expected = "World0";
const string Expression = "[[results(*).resfield]]";
int replaceCount;
payloadBuilder = replaceOperation.Replace(exidx, Expression, "hello", "World", false, payloadBuilder, out errors, out replaceCount, out entry);
var frames = payloadBuilder.FetchFrames();
var frame = frames[0].FetchNextFrameItem();
Assert.AreEqual(20, replaceCount);
Assert.AreEqual("[[results(1).resfield]]", frame.Expression);
Assert.AreEqual(Expected, frame.Value);
}
private int UpsertResult(int indexToUpsertTo, IDev2DataListUpsertPayloadBuilder <string> toUpsert, string result)
{
string expression;
if (DataListUtil.IsValueRecordset(Result) && DataListUtil.GetRecordsetIndexType(Result) == enRecordsetIndexType.Star)
{
expression = Result.Replace(GlobalConstants.StarExpression, indexToUpsertTo.ToString(CultureInfo.InvariantCulture));
}
else
{
expression = Result;
}
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
foreach (var region in DataListCleaningUtils.SplitIntoRegions(expression))
{
toUpsert.Add(region, result);
toUpsert.FlushIterationFrame();
indexToUpsertTo++;
}
return(indexToUpsertTo);
}
public void Dev2DataListUpsertPayloadBuilder_UnitTest_CanReplaceStarWithFixedIndexOnFlush()
{
IDev2DataListUpsertPayloadBuilder <string> builder = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
builder.ReplaceStarWithFixedIndex = true;
builder.Add("[[rs(*).val]]", "aaa");
builder.FlushIterationFrame();
builder.Add("[[rs(*).val]]", "aaa");
var items = builder.FetchFrames(true);
int idx = 1;
foreach (var itm in items)
{
var exp = itm.FetchNextFrameItem().Expression;
var expected = "rs(" + idx + ").val";
StringAssert.Contains(exp, expected, "Index substitution did not occur correctly");
idx++;
}
}
// ReSharper disable UnusedParameter.Local
void AddDebugTos(IDev2DataListUpsertPayloadBuilder <string> toUpsert, Guid executionId)
// ReSharper restore UnusedParameter.Local
{
int innerCount = 1;
const string VariableLabelText = "Variable";
const string NewFieldLabelText = "New Value";
foreach (DebugTO debugOutputTo in toUpsert.DebugOutputs)
{
if (debugOutputTo != null &&
debugOutputTo.TargetEntry != null &&
debugOutputTo.TargetEntry.ComplexExpressionAuditor != null)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugTOParams(debugOutputTo, true, VariableLabelText, NewFieldLabelText), debugItem);
innerCount++;
_debugInputs.Add(debugItem);
}
}
innerCount = 1;
foreach (DebugTO debugOutputTo in toUpsert.DebugOutputs)
{
if (debugOutputTo != null &&
debugOutputTo.TargetEntry != null &&
debugOutputTo.TargetEntry.ComplexExpressionAuditor != null)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem);
_debugOutputs.Add(debugItem);
innerCount++;
}
}
}
public void UpsertPayloadBuilder_FetchFrames_Expect_Ordered_Valid_Entries()
{
IDev2DataListUpsertPayloadBuilder <string> tmp = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
tmp.Add("[[scalar]]", "zzz");
tmp.FlushIterationFrame();
tmp.Add("[[scalar2]]", "aaa");
IList <string> expressions = new List <string>();
IList <string> values = new List <string>();
IList <IDataListPayloadIterationFrame <string> > frames = tmp.FetchFrames();
int frameID = 1;
foreach (IDataListPayloadIterationFrame <string> f in frames)
{
while (f.HasData())
{
DataListPayloadFrameTO <string> t2 = f.FetchNextFrameItem();
expressions.Add(t2.Expression + "." + frameID);
values.Add(t2.Value + "." + frameID);
}
frameID++;
}
IList <string> expectedExpressions = new List <string> {
"[[scalar]].1", "[[scalar2]].2"
};
CollectionAssert.AreEqual(expectedExpressions.ToArray(), expressions.ToArray());
CollectionAssert.AreEqual(expectedExpressions.ToArray(), expressions.ToArray());
}
// 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();
IDev2IndexFinder indexFinder = new Dev2IndexFinder();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();
IDev2DataListUpsertPayloadBuilder <string> toUpsertScalar = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder();
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsertScalar.IsDebug = dataObject.IsDebugMode();
try
{
IDev2IteratorCollection outerIteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection();
IDev2IteratorCollection innerIteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection();
allErrors.MergeErrors(errors);
IBinaryDataListEntry expressionsEntry = compiler.Evaluate(executionId, enActionType.User, Characters, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator itrChar = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntry);
outerIteratorCollection.AddIterator(itrChar);
#region Iterate and Find Index
expressionsEntry = compiler.Evaluate(executionId, enActionType.User, InField, false, out errors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugItemVariableParams(InField, "In Field", expressionsEntry, executionId));
AddDebugInputItem(new DebugItemStaticDataParams(Index, "Index"));
AddDebugInputItem(new DebugItemVariableParams(Characters, "Characters", itrChar.FetchEntry(), executionId));
AddDebugInputItem(new DebugItemStaticDataParams(Direction, "Direction"));
}
var completeResultList = new List <string>();
while (outerIteratorCollection.HasMoreData())
{
allErrors.MergeErrors(errors);
errors.ClearErrors();
IDev2DataListEvaluateIterator itrInField = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntry);
innerIteratorCollection.AddIterator(itrInField);
string chars = outerIteratorCollection.FetchNextRow(itrChar).TheValue;
while (innerIteratorCollection.HasMoreData())
{
if (!string.IsNullOrEmpty(InField) && !string.IsNullOrEmpty(Characters))
{
var val = innerIteratorCollection.FetchNextRow(itrInField);
if (val != null)
{
IEnumerable <int> returedData = indexFinder.FindIndex(val.TheValue, 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
{
var rsType = DataListUtil.GetRecordsetIndexType(Result);
if (rsType == enRecordsetIndexType.Numeric)
{
toUpsertScalar.Add(Result, string.Join(",", completeResultList));
compiler.Upsert(executionId, toUpsertScalar, out errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsertScalar.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
toUpsert.DebugOutputs.Clear();
}
}
else
{
toUpsert.Add(Result, completeResultList);
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
toUpsert.DebugOutputs.Clear();
}
}
}
#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);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
#endregion
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
/// <summary>
/// When overridden runs the activity's execution logic
/// </summary>
/// <param name="context">The context to be used.</param>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid dlId = dataObject.DataListID;
var allErrors = new ErrorResultTO();
ErrorResultTO errors;
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
IDev2DataListUpsertPayloadBuilder <IBinaryDataListEntry> toUpsert = Dev2DataListBuilderFactory.CreateBinaryDataListUpsertBuilder(true);
try
{
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsert.AttachDebugFromExpression = false;
toUpsert.RecordSetDataAsCSVToScalar = true;
toUpsert.ReplaceStarWithFixedIndex = true;
IBinaryDataListEntry rsEntry;
// We need to break up by , for InFields ;)
List <string> cols = BreakAndValidate(dlId, compiler, InFields, dataObject, true, out errors,
out rsEntry);
allErrors.MergeErrors(errors);
// Use row data?!, nope use row indexes ;)
List <string> resultFields = BreakAndValidate(dlId, compiler, ResultFields, dataObject,
false, out errors, out rsEntry);
allErrors.MergeErrors(errors);
compiler.Evaluate(dlId, enActionType.User, ResultFields, false, out errors);
allErrors.MergeErrors(errors);
compiler.Evaluate(dlId, enActionType.User, InFields, false, out errors);
allErrors.MergeErrors(errors);
// Fetch the unique data ;)
if (!allErrors.HasErrors())
{
List <int> uniqueRowIndexes = rsEntry.GetDistinctRows(cols);
var shadowList = new List <IBinaryDataListEntry>();
// And break and validate the target expressions ;)
List <string> targetExpressions = DataListCleaningUtils.SplitIntoRegions(Result);
if (!allErrors.HasErrors())
{
// process each row ;)
foreach (var uidx in uniqueRowIndexes)
{
int idx = 0;
// something in here is off ;)
foreach (var targetExp in targetExpressions)
{
string error;
// clone, prep and shove into the upsert payload builder ;)
var clone = rsEntry.Clone(enTranslationDepth.Data, dlId, out error);
allErrors.AddError(error);
clone.MakeRecordsetEvaluateReady(uidx, resultFields[idx], out error);
allErrors.AddError(error);
// We need to replace * with fixed index? else we will over write all data all the time ;)
toUpsert.Add(targetExp, clone);
shadowList.Add(clone);
idx++;
}
toUpsert.FlushIterationFrame();
}
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
// If in debug mode, we have data and there is the correct debug info balance ;)
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
int innerCount = 1;
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugItemVariableParams(debugOutputTo, targetExpressions.ToList()), itemToAdd);
UpdateStarNotationColumns(itemToAdd);
_debugOutputs.Add(itemToAdd);
innerCount++;
}
}
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFUnique", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfUniqueActivity", allErrors);
compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors && !String.IsNullOrEmpty(Result))
{
IBinaryDataListEntry entry = compiler.Evaluate(dlId, enActionType.User, Result, false, out errors);
AddDebugOutputItem(new DebugItemVariableParams(Result, "", entry, dlId));
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
/// <summary>
/// When overridden runs the activity's execution logic
/// </summary>
/// <param name="context">The context to be used.</param>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
_dataObject = dataObject;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid dlId = dataObject.DataListID;
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors;
Guid executionId = DataListExecutionID.Get(context);
int indexToUpsertTo = 0;
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
toUpsert.IsDebug = dataObject.IsDebugMode();
InitializeDebug(dataObject);
try
{
var colItr = Dev2ValueObjectFactory.CreateIteratorCollection();
IBinaryDataListEntry fromAccountEntry = compiler.Evaluate(dlId, enActionType.User, FromAccount ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator fromAccountItr = Dev2ValueObjectFactory.CreateEvaluateIterator(fromAccountEntry);
colItr.AddIterator(fromAccountItr);
IBinaryDataListEntry passwordEntry = compiler.Evaluate(dlId, enActionType.User, Password, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator passwordItr = Dev2ValueObjectFactory.CreateEvaluateIterator(passwordEntry);
colItr.AddIterator(passwordItr);
IBinaryDataListEntry toEntry = compiler.Evaluate(dlId, enActionType.User, To, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator toItr = Dev2ValueObjectFactory.CreateEvaluateIterator(toEntry);
colItr.AddIterator(toItr);
IBinaryDataListEntry ccEntry = compiler.Evaluate(dlId, enActionType.User, Cc ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator ccItr = Dev2ValueObjectFactory.CreateEvaluateIterator(ccEntry);
colItr.AddIterator(ccItr);
IBinaryDataListEntry bccEntry = compiler.Evaluate(dlId, enActionType.User, Bcc ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator bccItr = Dev2ValueObjectFactory.CreateEvaluateIterator(bccEntry);
colItr.AddIterator(bccItr);
IBinaryDataListEntry subjectEntry = compiler.Evaluate(dlId, enActionType.User, Subject ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator subjectItr = Dev2ValueObjectFactory.CreateEvaluateIterator(subjectEntry);
colItr.AddIterator(subjectItr);
IBinaryDataListEntry bodyEntry = compiler.Evaluate(dlId, enActionType.User, Body ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator bodyItr = Dev2ValueObjectFactory.CreateEvaluateIterator(bodyEntry);
colItr.AddIterator(bodyItr);
IBinaryDataListEntry attachmentsEntry = compiler.Evaluate(dlId, enActionType.User, Attachments ?? string.Empty, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator attachmentsItr = Dev2ValueObjectFactory.CreateEvaluateIterator(attachmentsEntry);
colItr.AddIterator(attachmentsItr);
var runtimeSource = ResourceCatalog.Instance.GetResource <EmailSource>(dataObject.WorkspaceID, SelectedEmailSource.ResourceID);
if (!allErrors.HasErrors())
{
while (colItr.HasMoreData())
{
if (IsDebug)
{
var fromAccount = FromAccount;
if (String.IsNullOrEmpty(fromAccount))
{
fromAccount = runtimeSource.UserName;
AddDebugInputItem(fromAccount, "From Account");
}
else
{
AddDebugInputItem(new DebugItemVariableParams(FromAccount, "From Account", fromAccountEntry, executionId));
}
AddDebugInputItem(new DebugItemVariableParams(To, "To", toEntry, executionId));
AddDebugInputItem(new DebugItemVariableParams(Subject, "Subject", subjectEntry, executionId));
AddDebugInputItem(new DebugItemVariableParams(Body, "Body", bodyEntry, executionId));
}
var result = SendEmail(runtimeSource, colItr, fromAccountItr, passwordItr, toItr, ccItr, bccItr, subjectItr, bodyItr, attachmentsItr, out errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
indexToUpsertTo = UpsertResult(indexToUpsertTo, toUpsert, result);
}
}
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
if (IsDebug && !allErrors.HasErrors())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
}
else
{
if (IsDebug)
{
AddDebugInputItem(FromAccount, "From Account");
AddDebugInputItem(To, "To");
AddDebugInputItem(Subject, "Subject");
AddDebugInputItem(Body, "Body");
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFEmail", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
if (allErrors.HasErrors())
{
UpsertResult(indexToUpsertTo, toUpsert, null);
compiler.Upsert(executionId, toUpsert, out errors);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfSendEmailActivity", allErrors);
compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
// ReSharper restore RedundantOverridenMember
protected override void OnExecute(NativeActivityContext context)
{
_debugOutputs.Clear();
_debugInputs.Clear();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false);
toUpsert.IsDebug = (dataObject.IsDebugMode());
toUpsert.ResourceID = dataObject.ResourceID;
InitializeDebug(dataObject);
ErrorResultTO errors = new ErrorResultTO();
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
try
{
if (!errors.HasErrors())
{
foreach (ActivityDTO t in FieldsCollection)
{
if (!string.IsNullOrEmpty(t.FieldName))
{
var fieldName = t.FieldName;
fieldName = DataListUtil.IsValueRecordset(fieldName) ? DataListUtil.ReplaceRecordsetIndexWithBlank(fieldName) : fieldName;
var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), enTranslationDepth.Shape, out errors).ToString();
if (!string.IsNullOrEmpty(datalist))
{
var isValidExpr = new IsValidExpressionRule(() => fieldName, datalist)
{
LabelText = fieldName
};
var errorInfo = isValidExpr.Check();
if (errorInfo != null)
{
t.FieldName = "";
errors.AddError(errorInfo.Message);
}
allErrors.MergeErrors(errors);
}
string eval = t.FieldValue;
if (eval.StartsWith("@"))
{
eval = GetEnviromentVariable(dataObject, context, eval);
}
toUpsert.Add(t.FieldName, eval);
}
}
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugTos(toUpsert, executionId);
}
allErrors.MergeErrors(errors);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfAssignActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugTos(toUpsert, executionId);
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
// ReSharper restore RedundantOverridenMember
/// <summary>
/// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity
/// </summary>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsert.ReplaceStarWithFixedIndex = true;
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
try
{
CleanArgs();
ICaseConverter converter = CaseConverterFactory.CreateCaseConverter();
allErrors.MergeErrors(errors);
int index = 1;
int outIndex = 0;
foreach (ICaseConvertTO item in ConvertCollection)
{
outIndex++;
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
allErrors.MergeErrors(errors);
ValidateVariable(item.Result, compiler, dataObject, out errors);
allErrors.MergeErrors(errors);
IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", index.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.StringToConvert, "Convert", tmp, executionId), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem);
_debugInputs.Add(debugItem);
index++;
}
if (tmp != null)
{
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp);
while (itr.HasMoreRecords())
{
foreach (IBinaryDataListItem itm in itr.FetchNextRowData())
{
try
{
IBinaryDataListItem res = converter.TryConvert(item.ConvertType, itm);
string expression = item.Result;
// 27.08.2013
// NOTE : The result must remain [ as this is how the fliping studio generates the result when using (*) notation
// There is a proper bug in to fix this issue, but since the studio is spaghetti I will leave this to the experts ;)
// This is a tmp fix to the issue
if (expression == "[" || DataListUtil.GetRecordsetIndexType(expression) == enRecordsetIndexType.Star)
{
expression = DataListUtil.AddBracketsToValueIfNotExist(res.DisplayValue);
}
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
IsSingleValueRule rule = new IsSingleValueRule(() => expression);
var singleresError = rule.Check();
if (singleresError != null)
{
allErrors.AddError(singleresError.Message);
}
else
{
toUpsert.Add(expression, res.TheValue);
// Upsert the entire payload
}
allErrors.MergeErrors(errors);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
toUpsert.Add(item.Result, null);
}
}
}
compiler.Upsert(executionId, toUpsert, out errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem);
_debugOutputs.Add(debugItem);
}
toUpsert.DebugOutputs.Clear();
}
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCaseConvertActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
int outIndex = 1;
foreach (ICaseConvertTO item in ConvertCollection)
{
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.Result, "", tmp, executionId), debugItem);
_debugOutputs.Add(debugItem);
outIndex++;
}
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
/// <summary>
/// When overridden runs the activity's execution logic
/// </summary>
/// <param name="context">The context to be used.</param>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid dlId = dataObject.DataListID;
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errorResultTo = new ErrorResultTO();
Guid executionId = dlId;
allErrors.MergeErrors(errorResultTo);
try
{
if (!errorResultTo.HasErrors())
{
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
IDev2IteratorCollection colItr = Dev2ValueObjectFactory.CreateIteratorCollection();
if (allErrors.HasErrors())
{
return;
}
IBinaryDataListEntry scriptEntry = compiler.Evaluate(executionId, enActionType.User, Script, false, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
if (allErrors.HasErrors())
{
return;
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(Script, scriptEntry, executionId);
}
int iterationCounter = 0;
while (colItr.HasMoreData())
{
dynamic value = null;
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
foreach (var region in DataListCleaningUtils.SplitIntoRegions(Result))
{
toUpsert.Add(region, null);
toUpsert.FlushIterationFrame();
if (dataObject.IsDebugMode())
{
// ReSharper disable ExpressionIsAlwaysNull
AddDebugOutputItem(new DebugOutputParams(region, value, executionId, iterationCounter));
// ReSharper restore ExpressionIsAlwaysNull
}
}
iterationCounter++;
}
compiler.Upsert(executionId, toUpsert, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
}
}
catch (Exception e)
{
allErrors.AddError(e.GetType() == typeof(NullReferenceException) ? "There was an error when returning a value from the javascript, remember to use the 'Return' keyword when returning the result" : e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfScriptingJavaScriptActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errorResultTo);
compiler.Upsert(executionId, Result, (string)null, out errorResultTo);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
// ReSharper restore RedundantOverridenMember
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2MergeOperations mergeOperations = new Dev2MergeOperations();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errorResultTo = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsert.ResourceID = dataObject.ResourceID;
InitializeDebug(dataObject);
try
{
CleanArguments(MergeCollection);
if (MergeCollection.Count <= 0)
{
return;
}
IDev2IteratorCollection iteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection();
allErrors.MergeErrors(errorResultTo);
Dictionary <int, List <IDev2DataListEvaluateIterator> > listOfIterators = new Dictionary <int, List <IDev2DataListEvaluateIterator> >();
#region Create a iterator for each row in the data grid in the designer so that the right iteration happen on the data
int dictionaryKey = 0;
foreach (DataMergeDTO row in MergeCollection)
{
IBinaryDataListEntry inputVariableExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.InputVariable, false, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
IBinaryDataListEntry atExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.At, false, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
IBinaryDataListEntry paddingExpressionEntry = compiler.Evaluate(executionId, enActionType.User, row.Padding, false, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
var fieldName = row.InputVariable;
var splitIntoRegions = DataListCleaningUtils.FindAllLanguagePieces(fieldName);
var datalist = compiler.ConvertFrom(dataObject.DataListID, DataListFormat.CreateFormat(GlobalConstants._Studio_XML), enTranslationDepth.Shape, out errorResultTo).ToString();
if (!string.IsNullOrEmpty(datalist))
{
foreach (var region in splitIntoRegions)
{
var r = DataListUtil.IsValueRecordset(region) ? DataListUtil.ReplaceRecordsetIndexWithBlank(region) : region;
var isValidExpr = new IsValidExpressionRule(() => r, datalist)
{
LabelText = fieldName
};
var errorInfo = isValidExpr.Check();
if (errorInfo != null)
{
row.InputVariable = "";
errorResultTo.AddError(errorInfo.Message);
}
allErrors.MergeErrors(errorResultTo);
}
}
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", (MergeCollection.IndexOf(row) + 1).ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(row.InputVariable, "", inputVariableExpressionEntry, executionId), debugItem);
AddDebugItem(new DebugItemStaticDataParams(row.MergeType, "With"), debugItem);
AddDebugItem(new DebugItemVariableParams(row.At, "Using", atExpressionEntry, executionId), debugItem);
AddDebugItem(new DebugItemVariableParams(row.Padding, "Pad", paddingExpressionEntry, executionId), debugItem);
//Old workflows don't have this set.
if (row.Alignment == null)
{
row.Alignment = string.Empty;
}
AddDebugItem(DataListUtil.IsEvaluated(row.Alignment) ? new DebugItemStaticDataParams("", row.Alignment, "Align") : new DebugItemStaticDataParams(row.Alignment, "Align"), debugItem);
_debugInputs.Add(debugItem);
}
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(inputVariableExpressionEntry);
IDev2DataListEvaluateIterator atItr = Dev2ValueObjectFactory.CreateEvaluateIterator(atExpressionEntry);
IDev2DataListEvaluateIterator padItr = Dev2ValueObjectFactory.CreateEvaluateIterator(paddingExpressionEntry);
iteratorCollection.AddIterator(itr);
iteratorCollection.AddIterator(atItr);
iteratorCollection.AddIterator(padItr);
listOfIterators.Add(dictionaryKey, new List <IDev2DataListEvaluateIterator> {
itr, atItr, padItr
});
dictionaryKey++;
}
#endregion
#region Iterate and Merge Data
if (!allErrors.HasErrors())
{
while (iteratorCollection.HasMoreData())
{
int pos = 0;
foreach (var iterator in listOfIterators)
{
var val = iteratorCollection.FetchNextRow(iterator.Value[0]);
var at = iteratorCollection.FetchNextRow(iterator.Value[1]);
var pad = iteratorCollection.FetchNextRow(iterator.Value[2]);
if (val != null)
{
if (at != null)
{
if (pad != null)
{
if (MergeCollection[pos].MergeType == "Index")
{
if (string.IsNullOrEmpty(at.TheValue))
{
allErrors.AddError("The 'Using' value cannot be blank.");
}
int atValue;
if (!Int32.TryParse(at.TheValue, out atValue) || atValue < 0)
{
allErrors.AddError("The 'Using' value must be a real number.");
}
if (pad.TheValue.Length > 1)
{
allErrors.AddError("'Padding' must be a single character");
}
}
else
{
if (MergeCollection[pos].MergeType == "Chars" && string.IsNullOrEmpty(at.TheValue))
{
allErrors.AddError("The 'Using' value cannot be blank.");
}
}
mergeOperations.Merge(val.TheValue, MergeCollection[pos].MergeType, at.TheValue, pad.TheValue, MergeCollection[pos].Alignment);
pos++;
}
}
}
}
}
if (!allErrors.HasErrors())
{
if (string.IsNullOrEmpty(Result))
{
AddDebugOutputItem(new DebugItemStaticDataParams("", ""));
}
else
{
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
toUpsert.Add(Result, mergeOperations.MergeData.ToString());
toUpsert.FlushIterationFrame();
compiler.Upsert(executionId, toUpsert, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
if (debugOutputTo.LeftEntry != null && debugOutputTo.TargetEntry != null)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
}
}
}
}
}
#endregion Iterate and Merge Data
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFDataMerge", e);
allErrors.AddError(e.Message);
}
finally
{
#region Handle Errors
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfDataMergeActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errorResultTo);
compiler.Upsert(executionId, Result, (string)null, out errorResultTo);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
#endregion
}
}
/// <summary>
/// Executes the logic of the activity and calls the backend code to do the work
/// Also responsible for adding the results to the data list
/// </summary>
/// <param name="context"></param>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDev2ReplaceOperation replaceOperation = Dev2OperationsFactory.CreateReplaceOperation();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(false);
toUpsert.IsDebug = dataObject.IsDebugMode();
ErrorResultTO errors;
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
IDev2IteratorCollection iteratorCollection = Dev2ValueObjectFactory.CreateIteratorCollection();
IBinaryDataListEntry expressionsEntryFind = compiler.Evaluate(executionId, enActionType.User, Find, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator itrFind = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntryFind);
iteratorCollection.AddIterator(itrFind);
IBinaryDataListEntry expressionsEntryReplaceWith = compiler.Evaluate(executionId, enActionType.User, ReplaceWith, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator itrReplace = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntryReplaceWith);
iteratorCollection.AddIterator(itrReplace);
int replacementCount = 0;
int replacementTotal = 0;
InitializeDebug(dataObject);
try
{
IList <string> toSearch = FieldsToSearch.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in toSearch)
{
if (dataObject.IsDebugMode())
{
IBinaryDataListEntry inFieldsEntry = compiler.Evaluate(executionId, enActionType.User, s, false, out errors);
AddDebugInputItem(new DebugItemVariableParams(s, "In Field(s)", inFieldsEntry, executionId));
}
}
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
while (iteratorCollection.HasMoreData())
{
// now process each field for entire evaluated Where expression....
var findValue = iteratorCollection.FetchNextRow(itrFind).TheValue;
var replaceWithValue = iteratorCollection.FetchNextRow(itrReplace).TheValue;
foreach (string s in toSearch)
{
if (!DataListUtil.IsEvaluated(s))
{
allErrors.AddError("Please insert only variables into Fields To Search");
return;
}
if (!string.IsNullOrEmpty(findValue))
{
IBinaryDataListEntry entryToReplaceIn;
toUpsert = replaceOperation.Replace(executionId, s.Trim(), findValue, replaceWithValue, CaseMatch, toUpsert, out errors, out replacementCount, out entryToReplaceIn);
}
replacementTotal += replacementCount;
allErrors.MergeErrors(errors);
}
}
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(new DebugItemVariableParams(Find, "Find", expressionsEntryFind, executionId));
AddDebugInputItem(new DebugItemVariableParams(ReplaceWith, "Replace With", expressionsEntryReplaceWith, executionId));
}
toUpsert.Add(Result, replacementTotal.ToString(CultureInfo.InvariantCulture));
// now push the result to the server
compiler.Upsert(executionId, toUpsert, out errors);
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
AddDebugOutputItem(new DebugItemVariableParams(debugOutputTo));
}
}
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception ex)
{
Dev2Logger.Log.Error("DSFReplace", ex);
allErrors.AddError(ex.Message);
}
finally
{
if (allErrors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DisplayAndWriteError("DsfReplaceActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
protected override void OnExecute(NativeActivityContext context)
{
_debugOutputs.Clear();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();
_isDebugMode = dataObject.IsDebugMode();
toUpsert.IsDebug = _isDebugMode;
toUpsert.ResourceID = dataObject.ResourceID;
ErrorResultTO errors = new ErrorResultTO();
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
XPathParser parser = new XPathParser();
int i = 0;
InitializeDebug(dataObject);
try
{
if (!errors.HasErrors())
{
IBinaryDataListEntry expressionsEntry = compiler.Evaluate(executionId, enActionType.User, SourceString, false, out errors);
if (_isDebugMode)
{
AddSourceStringDebugInputItem(SourceString, expressionsEntry, executionId);
AddResultDebugInputs(ResultsCollection, executionId, compiler, out errors);
allErrors.MergeErrors(errors);
}
if (!allErrors.HasErrors())
{
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntry);
while (itr.HasMoreRecords())
{
IList <IBinaryDataListItem> cols = itr.FetchNextRowData();
foreach (IBinaryDataListItem c in cols)
{
for (i = 0; i < ResultsCollection.Count; i++)
{
if (!string.IsNullOrEmpty(ResultsCollection[i].OutputVariable))
{
IBinaryDataListEntry xpathEntry = compiler.Evaluate(executionId, enActionType.User, ResultsCollection[i].XPath, false, out errors);
IDev2DataListEvaluateIterator xpathItr = Dev2ValueObjectFactory.CreateEvaluateIterator(xpathEntry);
while (xpathItr.HasMoreRecords())
{
IList <IBinaryDataListItem> xpathCols = xpathItr.FetchNextRowData();
foreach (IBinaryDataListItem xPathCol in xpathCols)
{
try
{
List <string> eval = parser.ExecuteXPath(c.TheValue, xPathCol.TheValue).ToList();
//2013.06.03: Ashley Lewis for bug 9498 - handle line breaks in multi assign
string[] openParts = Regex.Split(ResultsCollection[i].OutputVariable, @"\[\[");
string[] closeParts = Regex.Split(ResultsCollection[i].OutputVariable, @"\]\]");
if (openParts.Count() == closeParts.Count() && openParts.Count() > 2 && closeParts.Count() > 2)
{
foreach (var newFieldName in openParts)
{
if (!string.IsNullOrEmpty(newFieldName))
{
string cleanFieldName;
if (newFieldName.IndexOf("]]", StringComparison.Ordinal) + 2 < newFieldName.Length)
{
cleanFieldName = "[[" + newFieldName.Remove(newFieldName.IndexOf("]]", StringComparison.Ordinal) + 2);
}
else
{
cleanFieldName = "[[" + newFieldName;
}
toUpsert.Add(cleanFieldName, eval);
}
}
}
else
{
toUpsert.Add(ResultsCollection[i].OutputVariable, eval);
}
}
catch (Exception)
{
toUpsert.Add(ResultsCollection[i].OutputVariable, null);
}
}
}
}
}
compiler.Upsert(executionId, toUpsert, out errors);
}
allErrors.MergeErrors(errors);
}
}
if (_isDebugMode && !allErrors.HasErrors())
{
var innerCount = 1;
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugItemVariableParams(debugOutputTo), itemToAdd);
_debugOutputs.Add(itemToAdd);
innerCount++;
}
toUpsert.DebugOutputs.Clear();
}
}
}
catch (Exception ex)
{
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var actualIndex = i - 1;
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfXPathActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, ResultsCollection[actualIndex].OutputVariable, (string)null, out errors);
}
if (_isDebugMode)
{
if (hasErrors)
{
if (_isDebugMode)
{
ResultsCollection[actualIndex].XPath = "";
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", (actualIndex + 1).ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugOutputParams(ResultsCollection[actualIndex].OutputVariable, "", executionId, actualIndex + 1), itemToAdd);
_debugOutputs.Add(itemToAdd);
}
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
public IDev2DataListUpsertPayloadBuilder <string> Replace(Guid exIdx, string expression, string oldString, string newString, bool caseMatch, IDev2DataListUpsertPayloadBuilder <string> payloadBuilder, out ErrorResultTO errors, out int ReplaceCount, out IBinaryDataListEntry entryToReplaceIn)
{
ReplaceCount = 0;
oldString = oldString.Replace("\\", "\\\\");
// ReSharper disable RedundantAssignment
ErrorResultTO allErrors = new ErrorResultTO();
errors = new ErrorResultTO();
// ReSharper restore RedundantAssignment
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
entryToReplaceIn = compiler.Evaluate(exIdx, enActionType.User, expression, false, out errors);
allErrors.MergeErrors(errors);
if (entryToReplaceIn != null)
{
RegexOptions regexOptions;
if (caseMatch)
{
regexOptions = NoneCompiled;
}
else
{
regexOptions = IgnoreCaseCompiled;
}
//Massimo Guerrera - Added the Regex.Escape to escape certain characters - Bug 9937
Regex regex = new Regex(Regex.Escape(oldString), regexOptions);
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(entryToReplaceIn);
while (itr.HasMoreRecords())
{
IList <IBinaryDataListItem> rowList = itr.FetchNextRowData();
if (rowList != null)
{
foreach (IBinaryDataListItem binaryDataListItem in rowList)
{
int tmpCount = ReplaceCount;
string tmpVal = binaryDataListItem.TheValue;
if (tmpVal.Contains("\\") && oldString.Contains("\\"))
{
tmpVal = tmpVal.Replace("\\", "\\\\");
}
ReplaceCount += regex.Matches(tmpVal).Count;
if (ReplaceCount > tmpCount)
{
if (entryToReplaceIn.IsRecordset)
{
string recsetDisplayValue =
DataListUtil.CreateRecordsetDisplayValue(entryToReplaceIn.Namespace, binaryDataListItem.FieldName, binaryDataListItem.ItemCollectionIndex.ToString());
expression = string.Concat("[[", recsetDisplayValue, "]]");
}
var replaceValue = regex.Replace(tmpVal, newString);
payloadBuilder.Add(expression, replaceValue);
}
}
}
}
payloadBuilder.FlushIterationFrame();
}
else
{
allErrors.AddError("DataList entry is null.");
}
errors = allErrors;
return(payloadBuilder);
}
/// <summary>
/// Upserts the specified cur DLID.
/// </summary>
/// <param name="curDlid">The cur DLID.</param>
/// <param name="payload">The payload.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
public Guid Upsert(Guid curDlid, IDev2DataListUpsertPayloadBuilder <IBinaryDataListEntry> payload, out ErrorResultTO errors)
{
return(_svrCompiler.Upsert(null, curDlid, payload, out errors));
}
// 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);
}
}
}
