List <IDev2DataListEvaluateIterator> GetIteratorsFromInputMappings(IDataListCompiler compiler, Guid executionId, IDSFDataObject dataObject, IDev2IteratorCollection iteratorCollection, out ErrorResultTO errorsResultTo)
{
errorsResultTo = new ErrorResultTO();
var listOfIterators = new List <IDev2DataListEvaluateIterator>();
var indexCounter = 1;
foreach (var row in InputMappings)
{
if (String.IsNullOrEmpty(row.InputColumn))
{
continue;
}
ErrorResultTO invokeErrors;
var expressionsEntry = compiler.Evaluate(executionId, enActionType.User, row.InputColumn, false, out invokeErrors);
errorsResultTo.MergeErrors(invokeErrors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(row.InputColumn, row.OutputColumn.ColumnName, expressionsEntry, row.OutputColumn.DataTypeName, executionId, indexCounter);
indexCounter++;
}
var itr = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionsEntry);
iteratorCollection.AddIterator(itr);
listOfIterators.Add(itr);
}
return(listOfIterators);
}
public List <DebugItem> GetDebugInputs(IList <IDev2Definition> inputs, IBinaryDataList dataList, ErrorResultTO errors)
{
if (errors == null)
{
throw new ArgumentNullException("errors");
}
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var results = new List <DebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, GetVariableName(dev2Definition), false, out errors);
var val = tmpEntry.FetchScalar();
val.TheValue += "";
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(GetVariableName(dev2Definition), "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
void AddDebugInputItemFromEntry(string expression, string parameterName, IDataListCompiler compiler, Guid executionId, DebugItem debugItem)
{
ErrorResultTO errorsResultTo;
var expressionsEntry = compiler.Evaluate(executionId, enActionType.User, expression, false, out errorsResultTo);
AddDebugItem(new DebugItemVariableParams(expression, parameterName, expressionsEntry, executionId), debugItem);
}
public List <DebugItem> GetDebugValues(IList <IDev2Definition> values, IBinaryDataList dataList, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
IDataListCompiler compiler = _getDataListCompiler();
var results = new List <DebugItem>();
var added = new List <string>();
foreach (IDev2Definition dev2Definition in values)
{
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, GetVariableName(dev2Definition), false, out errors);
GetValue(tmpEntry, dev2Definition);
var defn = GetVariableName(dev2Definition);
if (added.Any(a => a == defn))
{
continue;
}
added.Add(defn);
DebugItem itemToAdd = new DebugItem();
_add(new DebugItemVariableParams(GetVariableName(dev2Definition), "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
public void NoResultVariableInAnyRow_Expected_Still_Split_But_Dont_Insert_Any()
{
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
_resultsCollection.Add(new DataSplitDTO("", "Index", "15", 1));
_resultsCollection.Add(new DataSplitDTO("", "Index", "15", 2));
SetupArguments("<root></root>", ActivityStrings.DataSplit_preDataList, _source, _resultsCollection);
IDSFDataObject result = ExecuteProcess();
List <bool> isPopulated = new List <bool>();
ErrorResultTO errors;
IBinaryDataList dList = compiler.FetchBinaryDataList(result.DataListID, out errors);
foreach (string data in dList.FetchAllUserKeys())
{
IBinaryDataListEntry entry;
string error;
dList.TryGetEntry(data, out entry, out error);
isPopulated.Add(entry.FetchAppendRecordsetIndex() != 1);
}
// remove test datalist ;)
DataListRemoval(result.DataListID);
CollectionAssert.DoesNotContain(isPopulated, true);
}
bool SqlExecution(ErrorResultTO errors, out object executeService)
{
try
{
if (SqlServer != null)
{
var parameters = GetSqlParameters(Service.Method.Parameters);
if (parameters != null)
{
// ReSharper disable CoVariantArrayConversion
using (var dataSet = SqlServer.FetchDataTable(parameters.ToArray()))
// ReSharper restore CoVariantArrayConversion
{
ApplyColumnMappings(dataSet);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
executeService = compiler.PopulateDataList(DataListFormat.CreateFormat(GlobalConstants._DATATABLE), dataSet, InstanceOutputDefintions, DataObj.DataListID, out errors);
return(true);
}
}
}
}
catch (Exception ex)
{
errors.AddError(string.Format("{0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace));
}
executeService = null;
return(false);
}
/// <summary>
/// Removes the dummy options from model.
/// </summary>
/// <param name="val">The val.</param>
/// <returns></returns>
public static string RemoveDummyOptionsFromModel(StringBuilder val)
{
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var tmp = val.Replace(@"""EvaluationFn"":""Choose...""", @"""EvaluationFn"":""Choose""");
// Hydrate and remove Choose options ;)
try
{
Dev2DecisionStack dds = compiler.ConvertFromJsonToModel <Dev2DecisionStack>(tmp);
if (dds.TheStack != null)
{
IList <Dev2Decision> toKeep = dds.TheStack.Where(item => item.EvaluationFn != enDecisionType.Choose).ToList();
dds.TheStack = toKeep;
}
tmp = compiler.ConvertModelToJson(dds);
}
catch (Exception ex)
{
Dev2Logger.Log.Error("Dev2DecisionStack", ex);
// Best effort ;)
}
return(tmp.ToString());
}
public override List <DebugItem> GetDebugOutputs(IBinaryDataList dataList)
{
IDev2LanguageParser parser = DataListFactory.CreateOutputParser();
IList <IDev2Definition> inputs = parser.Parse(OutputMapping);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var results = new List <DebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
ErrorResultTO errors;
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, dev2Definition.RawValue, false, out errors);
if (tmpEntry != null)
{
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(dev2Definition.RawValue, "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
else
{
if (errors.HasErrors())
{
throw new Exception(errors.MakeDisplayReady());
}
}
}
foreach (IDebugItem debugOutput in results)
{
debugOutput.FlushStringBuilder();
}
return(results);
}
public void DecisionWithQuotesInDataExpectedNoUnhandledExceptions()
{
Dev2DecisionStack dds = new Dev2DecisionStack {
TheStack = new List <Dev2Decision>(), Mode = Dev2DecisionMode.AND
};
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
dds.AddModelItem(new Dev2Decision {
Col1 = "[[var]]", Col2 = "[[var]]", EvaluationFn = enDecisionType.IsEqual
});
string modelData = dds.ToVBPersistableModel();
CurrentDl = "<ADL><var/></ADL>";
TestData = "<root><var>\"something \"data\" \"</var></root>";
ErrorResultTO errors;
Guid exeID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), new StringBuilder(TestData), new StringBuilder(CurrentDl), out errors);
IList <string> getDatalistID = new List <string> {
exeID.ToString()
};
var res = new Dev2DataListDecisionHandler().ExecuteDecisionStack(modelData, getDatalistID);
// remove test datalist ;)
DataListRemoval(exeID);
Assert.IsTrue(res);
}
public IBinaryDataList DeSerialize(string data, string targetShape, enTranslationTypes typeOf, out string error)
{
error = string.Empty;
IBinaryDataList result = Dev2BinaryDataListFactory.CreateDataList();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
if (typeOf == enTranslationTypes.XML)
{
ErrorResultTO errors;
Guid resultId = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._Studio_Debug_XML),
data.ToStringBuilder(),
new StringBuilder(targetShape), out errors);
if (errors.HasErrors())
{
error = errors.FetchErrors()[0]; // take the first error ;)
}
else
{
if (result != null)
{
compiler.ForceDeleteDataListByID(result.UID);
}
result = compiler.FetchBinaryDataList(resultId, out errors);
if (errors.HasErrors())
{
error = errors.FetchErrors()[0]; // take the first error ;)
}
}
}
return(result);
}
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);
}
public void XML_Without_SystemTags_ConvertTo_WhenSingleRecordset_ExpectNoErrors()
{
//------------Setup for test--------------------------
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
var data = new StringBuilder("<DataList><hero index=\"1\"><name>Chuck Norris</name><pushups>All of them</pushups></hero></DataList>");
var shape = new StringBuilder(@"<DataList>
<hero Description="""" IsEditable=""True"" ColumnIODirection=""Output"">
<name Description="""" IsEditable=""True"" ColumnIODirection=""Output"" />
<pushups Description="""" IsEditable=""True"" ColumnIODirection=""Output"" />
</hero>
<rect Description="""" IsEditable=""True"" ColumnIODirection=""None"">
<set Description="""" IsEditable=""True"" ColumnIODirection=""None"" />
</rect>
</DataList>");
//------------Execute Test---------------------------
var dlID = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), data, shape, out errors);
var result = compiler.ConvertFrom(dlID, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), enTranslationDepth.Data, out errors);
//------------Assert Results-------------------------
const string expected = "<DataList><hero><name>Chuck Norris</name><pushups>All of them</pushups></hero></DataList>";
StringAssert.Contains(result.ToString(), expected);
}
void PerformCustomErrorHandling(NativeActivityContext context, IDataListCompiler compiler, IDSFDataObject dataObject, string currentError, ErrorResultTO tmpErrors)
{
try
{
if (!String.IsNullOrEmpty(OnErrorVariable))
{
compiler.Upsert(dataObject.DataListID, OnErrorVariable, currentError, out tmpErrors);
}
if (!String.IsNullOrEmpty(OnErrorWorkflow))
{
var esbChannel = context.GetExtension <IEsbChannel>();
esbChannel.ExecuteLogErrorRequest(dataObject, dataObject.WorkspaceID, OnErrorWorkflow, out tmpErrors);
}
}
catch (Exception e)
{
if (tmpErrors == null)
{
tmpErrors = new ErrorResultTO();
}
tmpErrors.AddError(e.Message);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, tmpErrors.MakeDataListReady(), out errorsTo);
}
finally
{
if (IsEndedOnError)
{
PerformStopWorkflow(context, dataObject);
}
}
}
public override IBinaryDataList GetOutputs()
{
IBinaryDataList result;
ErrorResultTO errors;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var outputDlString = compiler.GenerateWizardDataListFromDefs(OutputMapping, enDev2ArgumentType.Output, false, out errors, true);
var outputDlShape = compiler.GenerateWizardDataListFromDefs(OutputMapping, enDev2ArgumentType.Output, false, out errors);
if (!errors.HasErrors())
{
Guid dlId = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), outputDlString, outputDlShape, out errors);
if (!errors.HasErrors())
{
result = compiler.FetchBinaryDataList(dlId, out errors);
}
else
{
string errorString = string.Join(",", errors.FetchErrors());
throw new Exception(errorString);
}
}
else
{
string errorString = string.Join(",", errors.FetchErrors());
throw new Exception(errorString);
}
return(result);
}
public List <IDebugItem> GetDebugInputs(IBinaryDataList dataList, IDataListCompiler compiler, IDev2LanguageParser parser)
{
IList <IDev2Definition> inputs = parser.Parse(InputMapping);
var results = new List <IDebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
ErrorResultTO errors;
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, dev2Definition.RawValue, false, out errors);
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(dev2Definition.RawValue, "", tmpEntry, dataList.UID), itemToAdd);
if (errors.HasErrors())
{
itemToAdd.FlushStringBuilder();
throw new DebugCopyException(errors.MakeDisplayReady(), itemToAdd);
}
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
public string WriteToResourceModel()
{
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
string result = string.Empty;
string errorString;
ScalarCollection.ForEach(FixNamingForScalar);
AddRecordsetNamesIfMissing();
IBinaryDataList postDl = ConvertIDataListItemModelsToIBinaryDataList(out errorString);
if (string.IsNullOrEmpty(errorString))
{
ErrorResultTO errors;
result = CreateXmlDataFromBinaryDataList(postDl, out errors);
if (Resource != null)
{
Resource.DataList = result;
}
}
compiler.ForceDeleteDataListByID(postDl.UID);
if (!string.IsNullOrEmpty(errorString))
{
throw new Exception(errorString);
}
return(result);
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public override List <DebugItem> GetDebugOutputs(IBinaryDataList dataList)
{
var result = new List <DebugItem>();
string resultString = _theResult.ToString();
DebugItem itemToAdd = new DebugItem();
IDataListCompiler c = DataListFactory.CreateDataListCompiler();
var val = new StringBuilder(Dev2DecisionStack.ExtractModelFromWorkflowPersistedData(ExpressionText));
try
{
Dev2DecisionStack dds = c.ConvertFromJsonToModel <Dev2DecisionStack>(val);
if (_theResult.ToString() == "True")
{
resultString = dds.TrueArmText;
}
else if (_theResult.ToString() == "False")
{
resultString = dds.FalseArmText;
}
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
catch (Exception)
{
if (!dataList.HasErrors())
{
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
}
return(result);
}
/// <summary>
/// Creates the list of data list item view model to bind to.
/// </summary>
/// <param name="errorString">The error string.</param>
/// <returns></returns>
public void CreateListsOfIDataListItemModelToBindTo(out string errorString)
{
errorString = string.Empty;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
if (!string.IsNullOrEmpty(Resource.DataList))
{
ErrorResultTO errors = new ErrorResultTO();
try
{
IBinaryDataList binarnyDl = CreateBinaryDataListFromXmlData(Resource.DataList, out errors);
if (!errors.HasErrors())
{
ConvertBinaryDataListToListOfIDataListItemModels(binarnyDl, out errorString);
}
else
{
string errorMessage = errors.FetchErrors().Aggregate(string.Empty, (current, error) => current + error);
throw new Exception(errorMessage);
}
if (binarnyDl != null)
{
compiler.ForceDeleteDataListByID(binarnyDl.UID);
}
}
catch (Exception)
{
errors.AddError("Invalid variable list. Please insure that your variable list has valid entries");
}
}
else
{
RecsetCollection.Clear();
AddRecordSet();
ScalarCollection.Clear();
}
BaseCollection = new OptomizedObservableCollection <DataListHeaderItemModel>();
DataListHeaderItemModel varNode = DataListItemModelFactory.CreateDataListHeaderItem("Variable");
if (ScalarCollection.Count == 0)
{
var dataListItemModel = DataListItemModelFactory.CreateDataListModel(string.Empty);
ScalarCollection.Add(dataListItemModel);
}
varNode.Children = ScalarCollection;
BaseCollection.Add(varNode);
//AddRecordsetNamesIfMissing();
DataListHeaderItemModel recordsetsNode = DataListItemModelFactory.CreateDataListHeaderItem("Recordset");
if (RecsetCollection.Count == 0)
{
AddRecordSet();
}
recordsetsNode.Children = RecsetCollection;
BaseCollection.Add(recordsetsNode);
}
public static ActivityUpsertTO CreateEntriesFromOutputTOs(IList<OutputTO> outputToList, IDataListCompiler compiler, Guid dlId, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
ActivityUpsertTO result = new ActivityUpsertTO();
foreach(OutputTO outputTo in outputToList)
{
// I first need to detect if the entry is a recordset!!!!!!!!!!!
// Then if scalar upsert scalar else upsert a recordset-- how was this to ever work?!?!
// Break into parts so we can correctly create the required entry......
IBinaryDataListEntry entry = Dev2BinaryDataListFactory.CreateEntry(RecsetName, string.Empty, dlId);
int idx = 1;
foreach(string output in outputTo.OutputStrings)
{
IBinaryDataListItem itemToAdd = Dev2BinaryDataListFactory.CreateBinaryItem(output, RecsetName, FieldName, idx);
idx++;
string error;
entry.TryAppendRecordItem(itemToAdd, out error);
if(error != string.Empty)
{
errors.AddError(error);
}
}
// push entry one time, no looping ;)
result.AddEntry(entry, outputTo.OutPutDescription);
}
return result;
}
// Travis.Frisinger - 28.01.2013 : Amended for Debug
public List <DebugItem> GetDebugOutputs(IExecutionEnvironment dataList, string _theResult)
{
var result = new List <DebugItem>();
string resultString = _theResult;
DebugItem itemToAdd = new DebugItem();
IDataListCompiler c = DataListFactory.CreateDataListCompiler();
var dds = Conditions;
try
{
if (_theResult == "True")
{
resultString = dds.TrueArmText;
}
else if (_theResult == "False")
{
resultString = dds.FalseArmText;
}
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
itemToAdd.AddRange(new DebugItemStaticDataParams(resultString, "").GetDebugItemResult());
result.Add(itemToAdd);
}
_inner.SetDebugOutputs(result);
return(result);
}
public override List <DebugItem> GetDebugInputs(IBinaryDataList dataList)
{
IDev2LanguageParser parser = DataListFactory.CreateInputParser();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
return(GetDebugInputs(dataList, compiler, parser).Select(a => (DebugItem)a).ToList());
}
/// <summary>
/// Resumed the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="bookmark">The bookmark.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.Exception">
/// Parent and Child DataList IDs are the same, aborting resumption!
/// or
/// Fatal Error : Cannot merge resumed data
/// or
/// Fatal Error : Cannot locate Root DataList for resumption!
/// </exception>
public virtual void Resumed(NativeActivityContext context, Bookmark bookmark, object value)
{
IDSFDataObject myDO = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errorResultTO = new ErrorResultTO();
Guid executionID = myDO.DataListID;
if (value != null)
{
Guid rootID;
Guid.TryParse(value.ToString(), out rootID);
if (executionID == rootID)
{
throw new Exception("Parent and Child DataList IDs are the same, aborting resumption!");
}
try
{
/* Now perform the shape.... */
// First set the parentID on executionID to rootID.. so the shape happens correctly ;)
compiler.SetParentID(rootID, executionID);
// Next shape the execution result into the root datalist ;)
ErrorResultTO tmpErrors;
Guid shapeID = compiler.Shape(rootID, enDev2ArgumentType.Output, OutputMapping, out tmpErrors);
errorResultTO.MergeErrors(tmpErrors);
// set parent instanceID
myDO.DataListID = executionID; // reset the DataListID accordingly
if (shapeID != executionID)
{
throw new Exception("Fatal Error : Cannot merge resumed data");
}
compiler.ConditionalMerge(DataListMergeFrequency.Always | DataListMergeFrequency.OnResumption,
myDO.DatalistOutMergeID, myDO.DataListID, myDO.DatalistOutMergeFrequency, myDO.DatalistOutMergeType, myDO.DatalistOutMergeDepth);
ExecutionStatusCallbackDispatcher.Instance.Post(myDO.BookmarkExecutionCallbackID, ExecutionStatusCallbackMessageType.ResumedCallback);
}
finally
{
// At resumption this is the root dl entry ;)
// Handle Errors
if (errorResultTO.HasErrors())
{
DisplayAndWriteError("Resumption", errorResultTO);
var errorString = errorResultTO.MakeDataListReady();
myDO.Environment.AddError(errorString);
}
}
}
else
{
throw new Exception("Fatal Error : Cannot locate Root DataList for resumption!");
}
}
void AddErrorToDataList(Exception err, IDataListCompiler compiler, IDSFDataObject dataObject)
{
var errorString = err.Message;
var errorResultTO = new ErrorResultTO();
errorResultTO.AddError(errorString);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, errorResultTO.MakeUserReady(), out errorsTo);
}
/// <summary>
/// Inits the entry point.
/// </summary>
/// <param name="workflowActivity">The workflow activity.</param>
/// <param name="dataTransferObject">The data transfer object.</param>
/// <param name="executionExtensions">The execution extensions.</param>
/// <param name="instanceId">The instance id.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="bookmarkName">Name of the bookmark.</param>
/// <returns></returns>
// ReSharper disable once UnusedParameter.Local // ignored as not sure how this method is invoked and what the knock on effect maybe
private WorkflowApplication InitEntryPoint(Activity workflowActivity, IDSFDataObject dataTransferObject, IEnumerable <object> executionExtensions, Guid instanceId, IWorkspace workspace, string bookmarkName)
{
dataTransferObject.WorkspaceID = workspace.ID;
Dictionary <string, object> inputarguments = new Dictionary <string, object>();
WorkflowApplication wfApp = null;
Guid parentInstanceID = FetchParentInstanceId(dataTransferObject);
if (parentInstanceID != Guid.Empty)
{
inputarguments.Add("ParentWorkflowInstanceId", parentInstanceID);
if (!string.IsNullOrEmpty(dataTransferObject.ParentServiceName))
{
inputarguments.Add("ParentServiceName", dataTransferObject.ParentServiceName);
}
}
// Set the old AmbientDatalist as the DataListID ;)
inputarguments.Add("AmbientDataList", new List <string> {
dataTransferObject.DataListID.ToString()
});
if ((parentInstanceID != Guid.Empty && instanceId == Guid.Empty) || string.IsNullOrEmpty(bookmarkName))
{
wfApp = new WorkflowApplication(workflowActivity, inputarguments);
}
else
{
if (!string.IsNullOrEmpty(bookmarkName))
{
wfApp = new WorkflowApplication(workflowActivity);
}
}
if (wfApp != null)
{
wfApp.InstanceStore = InstanceStore;
if (executionExtensions != null)
{
executionExtensions.ToList().ForEach(exec => wfApp.Extensions.Add(exec));
}
// Force a save to the server ;)
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataLanguageParser parser = DataListFactory.CreateLanguageParser();
wfApp.Extensions.Add(dataTransferObject);
wfApp.Extensions.Add(compiler);
wfApp.Extensions.Add(parser);
}
return(wfApp);
}
static string ExtractKeyValuePairs(NameValueCollection pairs)
{
IBinaryDataList bdl = Dev2BinaryDataListFactory.CreateDataList();
// Extract request keys ;)
foreach (var key in pairs.AllKeys)
{
if (key == "wid") //Don't add the Workspace ID to DataList
{
continue;
}
if (key.IsXml())
{
return(key); //We have a workspace id and XML DataList
}
string error;
bdl.TryCreateScalarTemplate(string.Empty, key, string.Empty, true, out error);
if (!string.IsNullOrEmpty(error))
{
Dev2Logger.Log.Error(error);
}
IBinaryDataListEntry entry;
if (bdl.TryGetEntry(key, out entry, out error))
{
var item = Dev2BinaryDataListFactory.CreateBinaryItem(pairs[key], key);
entry.TryPutScalar(item, out error);
if (!string.IsNullOrEmpty(error))
{
Dev2Logger.Log.Error(error);
}
}
else
{
Dev2Logger.Log.Error(error);
}
}
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
Guid pushedId = compiler.PushBinaryDataList(bdl.UID, bdl, out errors);
if (pushedId != Guid.Empty)
{
var result = compiler.ConvertFrom(pushedId, DataListFormat.CreateFormat(GlobalConstants._XML), enTranslationDepth.Data, out errors);
if (errors.HasErrors())
{
Dev2Logger.Log.Error(errors.MakeDisplayReady());
}
return(result.ToString());
}
Dev2Logger.Log.Error(errors.MakeDisplayReady());
return(string.Empty);
}
public string GetXMLForInputs(IBinaryDataList binaryDataList)
{
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
return
(compiler.ConvertFrom(binaryDataList.UID, DataListFormat.CreateFormat(GlobalConstants._XML_Inputs_Only),
enTranslationDepth.Data, out errors).ToString());
}
protected static IBinaryDataList GetDataList(NativeActivityContext context)
{
var dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
return(compiler.FetchBinaryDataList(dataObject.DataListID, out errors));
}
public virtual Guid Execute(out ErrorResultTO errors)
{
//This execution will throw errors from the constructor
errors = new ErrorResultTO();
errors.MergeErrors(ErrorResult);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ExecuteImpl(compiler, out errors);
return(DataObj.DataListID);
}
/// <summary>
/// Creates the XML data from binary data list.
/// </summary>
/// <param name="binaryDataList">The binary data list.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
private string CreateXmlDataFromBinaryDataList(IBinaryDataList binaryDataList, out ErrorResultTO errors)
{
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
Guid dlGuid = compiler.PushBinaryDataList(binaryDataList.UID, binaryDataList, out errors);
string result = compiler.ConvertFrom(dlGuid,
DataListFormat.CreateFormat(GlobalConstants._Studio_XML),
enTranslationDepth.Shape, out errors).ToString();
return(result);
}
protected override void AddItemsToIterator(Guid executionId, IDataListCompiler compiler, List <ErrorResultTO> errors)
{
ErrorResultTO error;
IBinaryDataListEntry archPassEntry = compiler.Evaluate(executionId, enActionType.User, ArchivePassword, false,
out error);
errors.Add(error);
_archPassItr = Dev2ValueObjectFactory.CreateEvaluateIterator(archPassEntry);
ColItr.AddIterator(_archPassItr);
}
public virtual void CleanUp()
{
CleanUpCalled = true;
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
if (BinaryDataList != null)
{
compiler.ForceDeleteDataListByID(BinaryDataList.UID);
BinaryDataList.Dispose();
}
}
//MO - Changed : new ctor that accepts the new arguments
public ForEachBootstrapTOOld(enForEachType forEachType, string from, string to, string csvNumbers, string numberOfExecutes, string recordsetName, Guid dlID, IDataListCompiler compiler, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
ForEachType = forEachType;
IDev2IteratorCollection colItr = Dev2ValueObjectFactory.CreateIteratorCollection();
IndexIterator localIndexIterator;
IndexList indexList;
switch(forEachType)
{
case enForEachType.InRecordset:
IBinaryDataListEntry recordset = compiler.Evaluate(dlID, enActionType.User, recordsetName, false, out errors);
if(recordset == null || !recordset.IsRecordset)
{
errors.AddError("When selecting a recordset only valid recordsets can be used");
break;
}
var isEmpty = recordset.IsEmpty();
if(isEmpty)
{
indexList = new IndexList(new HashSet<int> { 1 }, 0);
localIndexIterator = new IndexIterator(new HashSet<int> { 1 }, 0);
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = 1, MaxValue = recordset.FetchLastRecordsetIndex() };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0);
}
localIndexIterator.IndexList = indexList;
IndexIterator = localIndexIterator;
break;
case enForEachType.InRange:
if(string.IsNullOrWhiteSpace(from))
{
errors.AddError("The from field can not be left empty.");
break;
}
if(string.IsNullOrWhiteSpace(to))
{
errors.AddError("The to field can not be left empty.");
break;
}
if(from.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the From field.");
break;
}
var fromItr = CreateDataListEvaluateIterator(from, dlID, compiler, colItr, errors);
colItr.AddIterator(fromItr);
int intFrom;
if(!int.TryParse(colItr.FetchNextRow(fromItr).TheValue, out intFrom) || intFrom < 1)
{
errors.AddError("From range must be a whole number from 1 onwards.");
break;
}
if(to.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the To field.");
break;
}
var toItr = CreateDataListEvaluateIterator(to, dlID, compiler, colItr, errors);
colItr.AddIterator(toItr);
int intTo;
if(!int.TryParse(colItr.FetchNextRow(toItr).TheValue, out intTo) || intTo < 1)
{
errors.AddError("To range must be a whole number from 1 onwards.");
break;
}
if(intFrom > intTo)
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
ReverseIndexIterator revIdxItr = new ReverseIndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = revIdxItr;
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = localIndexIterator;
}
break;
case enForEachType.InCSV:
var csvIndexedsItr = CreateDataListEvaluateIterator(csvNumbers, dlID, compiler, colItr, errors);
colItr.AddIterator(csvIndexedsItr);
ErrorResultTO allErrors;
List<int> listOfIndexes = SplitOutCsvIndexes(colItr.FetchNextRow(csvIndexedsItr).TheValue, out allErrors);
if(allErrors.HasErrors())
{
errors.MergeErrors(allErrors);
break;
}
ListIndexIterator listLocalIndexIterator = new ListIndexIterator(listOfIndexes);
ListOfIndex listOfIndex = new ListOfIndex(listOfIndexes);
listLocalIndexIterator.IndexList = listOfIndex;
IndexIterator = listLocalIndexIterator;
break;
default:
if(numberOfExecutes != null && numberOfExecutes.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the Numbers field.");
break;
}
int intExNum;
var numOfExItr = CreateDataListEvaluateIterator(numberOfExecutes, dlID, compiler, colItr, errors);
colItr.AddIterator(numOfExItr);
if(!int.TryParse(colItr.FetchNextRow(numOfExItr).TheValue, out intExNum))
{
errors.AddError("Number of executes must be a whole number from 1 onwards.");
}
IndexIterator = new IndexIterator(new HashSet<int>(), intExNum);
break;
}
}
IDev2DataListEvaluateIterator CreateDataListEvaluateIterator(string expression, Guid executionId, IDataListCompiler compiler, IDev2IteratorCollection iteratorCollection, ErrorResultTO allErrors)
{
ErrorResultTO errors;
IBinaryDataListEntry expressionEntry = compiler.Evaluate(executionId, enActionType.User, expression, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator expressionIterator = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionEntry);
iteratorCollection.AddIterator(expressionIterator);
return expressionIterator;
}
