ErrorResultTO TryInvokeService(IDSFDataObject dataObject, ErrorResultTO errors)
{
var serviceId = dataObject.ResourceID;
var serviceName = dataObject.ServiceName;
if (serviceId == Guid.Empty && string.IsNullOrEmpty(serviceName))
{
errors.AddError(Resources.DynamicServiceError_ServiceNotSpecified);
}
else
{
try
{
errors = InvokeService(dataObject, errors, serviceId, serviceName);
}
catch (Exception e)
{
errors.AddError(e.Message, true);
}
finally
{
var environment = dataObject.Environment;
if (environment.HasErrors())
{
var errorString = environment.FetchErrors();
var executionErrors = ErrorResultTO.MakeErrorResultFromDataListString(errorString, true);
errors.MergeErrors(executionErrors);
}
if (dataObject.ReturnType == Web.EmitionTypes.XML || dataObject.ReturnType == Web.EmitionTypes.TRX)
{
environment.AddError(errors.MakeDataListReady(), true);
}
else
{
environment.AddError(errors.MakeDataListReady(false), true);
}
if (errors.HasErrors())
{
Dev2Logger.Error(errors.MakeDisplayReady(), dataObject.ExecutionID.ToString());
}
}
}
return(errors);
}
/// <summary>
/// When overridden runs the activity's simulation logic
/// </summary>
/// <param name="context">The context to be used.</param>
// ReSharper disable VirtualMemberNeverOverriden.Global
protected virtual void OnExecuteSimulation(NativeActivityContext context)
// ReSharper restore VirtualMemberNeverOverriden.Global
{
var rootInfo = context.GetExtension <WorkflowInstanceInfo>();
var key = new SimulationKey
{
WorkflowID = rootInfo.ProxyName,
ActivityID = UniqueID,
ScenarioID = ScenarioID
};
var result = SimulationRepository.Instance.Get(key);
if (result != null && result.Value != null)
{
var dataObject = context.GetExtension <IDSFDataObject>();
if (dataObject != null)
{
var allErrors = new ErrorResultTO();
allErrors.MergeErrors(errorsTo);
allErrors.MergeErrors(errorsTo);
allErrors.MergeErrors(errorsTo);
if (allErrors.HasErrors())
{
DisplayAndWriteError(rootInfo.ProxyName, allErrors);
dataObject.Environment.AddError(allErrors.MakeDataListReady());
}
}
}
}
void ProcessErrors(IDSFDataObject dataObject, int update, bool hasErrors, ErrorResultTO allErrors, int actualIndex)
{
if (hasErrors)
{
var errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
if (actualIndex > -1)
{
dataObject.Environment.Assign(ResultsCollection[actualIndex].OutputVariable, null, update);
}
DisplayAndWriteError(dataObject, DisplayName, allErrors);
if (_isDebugMode)
{
var itemToAdd = new DebugItem();
if (actualIndex < 0)
{
actualIndex = 0;
}
AddDebugItem(new DebugItemStaticDataParams("", (actualIndex + 1).ToString(CultureInfo.InvariantCulture)), itemToAdd);
var outputVariable = "";
if (actualIndex >= 0)
{
outputVariable = ResultsCollection[actualIndex].OutputVariable;
}
AddDebugItem(new DebugEvalResult(outputVariable, "", dataObject.Environment, update), itemToAdd);
_debugOutputs.Add(itemToAdd);
}
}
}
/// <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!");
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errorResultTo = new ErrorResultTO();
allErrors.MergeErrors(errorResultTo);
try
{
if (!errorResultTo.HasErrors())
{
if (allErrors.HasErrors())
{
return;
}
allErrors.MergeErrors(errorResultTo);
if (allErrors.HasErrors())
{
return;
}
if (dataObject.IsDebugMode())
{
AddDebugInputItem(Script, dataObject.Environment, update);
}
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);
dataObject.Environment.AddError(allErrors.MakeDataListReady());
dataObject.Environment.Assign(Result, null, update);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
public void ErrorResultTO_AddError_NullMessage()
{
var resultTo = new ErrorResultTO();
resultTo.AddError(null, true);
Assert.IsFalse(resultTo.HasErrors());
// Shouldn't this be passing?
Assert.AreEqual(0, resultTo.FetchErrors().Count);
Assert.AreEqual("", resultTo.MakeDataListReady());
}
static string SetupErrors(IDSFDataObject dataObject, ErrorResultTO allErrors)
{
string executePayload;
if (dataObject.ReturnType == EmitionTypes.XML)
{
executePayload =
"<FatalError> <Message> An internal error occurred while executing the service request </Message>";
executePayload += allErrors.MakeDataListReady();
executePayload += "</FatalError>";
}
else
{
executePayload =
"{ \"FatalError\": \"An internal error occurred while executing the service request\",";
executePayload += allErrors.MakeDataListReady(false);
executePayload += "}";
}
return(executePayload);
}
public void ErrorResultTO_AddError_CheckForDuplicates_True_AddSameError_ExpectLstToBeSame()
{
var resultTo = new ErrorResultTO();
resultTo.AddError("some message", true);
resultTo.AddError("some message", true);
Assert.IsTrue(resultTo.HasErrors());
Assert.AreEqual(1, resultTo.FetchErrors().Count);
Assert.AreEqual("some message", resultTo.FetchErrors()[0]);
Assert.AreEqual("<InnerError>some message</InnerError>", resultTo.MakeDataListReady());
}
public void CanConvertErrorResultTojson()
{
ErrorResultTO errors = new ErrorResultTO();
errors.AddError("Error 1");
errors.AddError("Error 2");
var result = errors.MakeDataListReady(false);
const string expected = "\"errors\": [ \"Error 1\",\"Error 2\"]";
Assert.AreEqual(expected, result, "Expected [ " + expected + " but got [ " + result + " ]");
}
public void ErrorResultTO_MakeDatalistReady_CannotSetUnknownMemberError_MessageConvertedToOutdatedServerError()
{
var errorResultTO = new ErrorResultTO();
errorResultTO.AddError("Cannot set unknown member");
//------------Execute Test---------------------------
var result = errorResultTO.MakeDataListReady(false);
const string expected = "\"errors\": [ \"Resource has unrecognized formatting, this Warewolf Server may be to outdated to read this resource.\"]";
// Assert Message Converted To Outdated Server Error
Assert.AreEqual(expected, result, "Error message not relevent");
}
public void ErrorResultTO_MakeDataListReady_ExpectJson_ShouldEscapeQuotesInErrorMessages()
{
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("this is some exception's \"message\" string");
errorResultTo.AddError("Another \"Error\"");
errorResultTo.AddError("\"Error\" message");
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
var result = "\"errors\": [ \"this is some exception's \\\"message\\\" string\",\"Another \\\"Error\\\"\",\"\\\"Error\\\" message\"]";
Assert.AreEqual(result, makeDisplayReady);
}
public void ErrorResultTO_MakeDataListReady_ExpectJson_ShouldEscapeQuotesInErrorMessages()
{
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("this is some exception's \"message\" string");
errorResultTo.AddError("Another \"Error\"");
errorResultTo.AddError("\"Error\" message");
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
var result = "[ \"this is some exception's \\\"message\\\" string\",\"Another \\\"Error\\\"\",\"\\\"Error\\\" message\"]";
Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used");
}
public void ErrorResultTO_MakeDataListReady_ShouldReturnAllErrorsAsOne()
{
var result = "<InnerError>SomeError</InnerError><InnerError>AnotherError</InnerError>";
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("AnotherError");
Assert.AreEqual(2, errorResultTo.FetchErrors().Count);
var makeDisplayReady = errorResultTo.MakeDataListReady();
Assert.AreEqual(result, makeDisplayReady);
}
public void ErrorResultTO_MakeDataListReady_AsXmlFalseShouldReturnAllErrorsAsOne()
{
var result = "[ \"SomeError\",\"AnotherError\"]";
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("AnotherError");
Assert.AreEqual(2, errorResultTo.FetchErrors().Count);
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used");
}
public void ErrorResultTO_MakeDataListReady_AsXmlFalseShouldReturnAllErrorsAsOne()
{
var result = "\"errors\": [ \"SomeError\",\"AnotherError\"]";
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("AnotherError");
Assert.AreEqual(2, errorResultTo.FetchErrors().Count);
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
Assert.AreEqual(result, makeDisplayReady);
}
public void ErrorResultTO_MakeDataListReady_CannotSetUnknownMember_RemapsErrorMessage()
{
var result = "\"errors\": [ \"SomeError\",\"Resource has unrecognized formatting, this Warewolf Server may be to outdated to read this resource.\",\"Another Error\"]";
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("Cannot set unknown member");
errorResultTo.AddError("Another Error");
Assert.AreEqual(3, errorResultTo.FetchErrors().Count);
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
Assert.AreEqual(result, makeDisplayReady);
}
public void ErrorResultTO_MakeDataListReady_CannotSetUnknownMember_RemapsErrorMessage()
{
var result = "[ \"SomeError\",\"Resource has unrecognized formatting, this Warewolf Server may be to outdated to read this resource.\",\"Another Error\"]";
var errorResultTo = new ErrorResultTO();
Assert.AreEqual(0, errorResultTo.FetchErrors().Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("Cannot set unknown member");
errorResultTo.AddError("Another Error");
Assert.AreEqual(3, errorResultTo.FetchErrors().Count);
var makeDisplayReady = errorResultTo.MakeDataListReady(false);
Assert.AreEqual(result, makeDisplayReady, "\"errors\": prefix have been removed to keep with the xml add error of this method as it seems to be the most used");
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
var errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
ValidateRecordsetName(RecordsetName, errors);
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
try
{
TryExecuteTool(dataObject, update, allErrors);
}
catch (Exception e)
{
AddDebugInputItem(new DebugItemStaticDataParams("", RecordsetName, "Recordset", "="));
allErrors.AddError(e.Message);
dataObject.Environment.Assign(CountNumber, "0", update);
AddDebugOutputItem(new DebugItemStaticDataParams("0", CountNumber, "", "="));
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
var errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
DisplayAndWriteError(dataObject, DisplayName, allErrors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
ErrorResultTO TryInvokeService(IDSFDataObject dataObject, ErrorResultTO errors)
{
var serviceId = dataObject.ResourceID;
var serviceName = dataObject.ServiceName;
if (serviceId == Guid.Empty && string.IsNullOrEmpty(serviceName))
{
errors.AddError(Resources.DynamicServiceError_ServiceNotSpecified);
}
else
{
try
{
errors = InvokeService(dataObject, errors, serviceId, serviceName);
}
catch (Exception e)
{
errors.AddError(e.Message);
}
finally
{
var environment = dataObject.Environment;
if (environment.HasErrors())
{
var errorString = environment.FetchErrors();
var executionErrors = ErrorResultTO.MakeErrorResultFromDataListString(errorString);
errors.MergeErrors(executionErrors);
}
environment.AddError(errors.MakeDataListReady());
if (errors.HasErrors())
{
Dev2Logger.Error(errors.MakeDisplayReady(), GlobalConstants.WarewolfError);
}
}
}
return(errors);
}
void HandleErrors(IDSFDataObject dataObject, int update, ErrorResultTO allErrors)
{
var hasErrors = allErrors.HasErrors();
if (!hasErrors && dataObject.Environment.Errors.Any())
{
DisplayAndWriteError(dataObject, DisplayName, allErrors);
}
if (hasErrors)
{
var errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
DisplayAndWriteError(dataObject, DisplayName, allErrors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
/// <summary>
/// When overridden runs the activity's simulation logic
/// </summary>
/// <param name="context">The context to be used.</param>
protected virtual void OnExecuteSimulation(NativeActivityContext context)
{
var rootInfo = context.GetExtension <WorkflowInstanceInfo>();
var key = new SimulationKey
{
WorkflowID = rootInfo.ProxyName,
ActivityID = UniqueID,
ScenarioID = ScenarioID
};
var result = SimulationRepository.Instance.Get(key);
if (result != null && result.Value != null)
{
var dataListExecutionID = context.GetValue(DataListExecutionID);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var dataObject = context.GetExtension <IDSFDataObject>();
if (compiler != null && dataObject != null)
{
var allErrors = new ErrorResultTO();
var dataList = compiler.FetchBinaryDataList(dataObject.DataListID, out errorsTo);
allErrors.MergeErrors(errorsTo);
compiler.Merge(dataList, result.Value, enDataListMergeTypes.Union, enTranslationDepth.Data, false, out errorsTo);
allErrors.MergeErrors(errorsTo);
compiler.Shape(dataListExecutionID, enDev2ArgumentType.Output, OutputMapping, out errorsTo);
allErrors.MergeErrors(errorsTo);
if (allErrors.HasErrors())
{
DisplayAndWriteError(rootInfo.ProxyName, allErrors);
dataObject.Environment.AddError(allErrors.MakeDataListReady());
}
}
}
}
private void DebugOutput(IDSFDataObject dataObject, int update, ErrorResultTO allErrors, string parentServiceName, string serviceName, Guid oldResourceId)
{
if (!dataObject.WorkflowResumeable || !dataObject.IsDataListScoped)
{
// Handle Errors
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfActivity", allErrors);
foreach (var allError in allErrors.FetchErrors())
{
dataObject.Environment.Errors.Add(allError);
}
// add to datalist in variable specified
if (!String.IsNullOrEmpty(OnErrorVariable))
{
var upsertVariable = DataListUtil.AddBracketsToValueIfNotExist(OnErrorVariable);
dataObject.Environment.Assign(upsertVariable, allErrors.MakeDataListReady(), update);
}
}
}
if (dataObject.IsDebugMode() || dataObject.RunWorkflowAsync && !dataObject.IsFromWebServer)
{
var dt = DateTime.Now;
DispatchDebugState(dataObject, StateType.After, update, dt);
ChildDebugStateDispatch(dataObject);
_debugOutputs = new List <DebugItem>();
DispatchDebugState(dataObject, StateType.Duration, update, dt);
}
dataObject.ParentInstanceID = _previousInstanceId;
dataObject.ParentServiceName = parentServiceName;
dataObject.ServiceName = serviceName;
dataObject.RemoteInvokeResultShape = new StringBuilder(); // reset targnet shape ;)
dataObject.RunWorkflowAsync = false;
dataObject.RemoteInvokerID = Guid.Empty.ToString();
dataObject.EnvironmentID = Guid.Empty;
dataObject.ResourceID = oldResourceId;
}
public void ErrorResultTO_MakeDataListReady_ShouldReturnAllErrorsAsOne()
{
var result = "<InnerError>SomeError</InnerError><InnerError>AnotherError</InnerError>";
var errorResultTo = new ErrorResultTO();
Assert.IsNotNull(errorResultTo);
var prObj = new PrivateObject(errorResultTo);
var errors = prObj.GetField("_errorList") as IList <string>;
Assert.IsNotNull(errors);
Assert.AreEqual(0, errors.Count);
errorResultTo.AddError("SomeError");
errorResultTo.AddError("AnotherError");
errors = prObj.GetField("_errorList") as IList <string>;
if (errors != null)
{
Assert.AreEqual(2, errors.Count);
}
var makeDisplayReady = errorResultTo.MakeDataListReady();
Assert.AreEqual(result, makeDisplayReady);
}
/// <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>();
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
{
}
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!");
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
var errors = new ErrorResultTO();
_executionResult = new List <string>();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
TryExecute(dataObject, update, allErrors, errors);
}
catch (Exception ex)
{
Dev2Logger.Error(string.Format("{0} Exception", DisplayName), ex, GlobalConstants.WarewolfError);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError(DisplayName, allErrors);
var errorList = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorList);
dataObject.Environment.Assign(Result, DisplayName.ToUpper().Contains("Dropbox".ToUpper()) ? GlobalConstants.DropBoxFailure : null, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
var errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
JsonMappings = JsonMappings.Where(validMapping).ToList();
// Process if no errors
try
{
if (JsonMappings == null)
{
dataObject.Environment.AddError("Json Mappings supplied to activity is null.");
}
// ReSharper disable AssignNullToNotNullAttribute
if (!dataObject.Environment.Errors.Any() && !JsonMappings.Any())
// ReSharper restore AssignNullToNotNullAttribute
{
dataObject.Environment.AddError("No Json Mappings supplied to activity.");
}
// ReSharper disable AssignNullToNotNullAttribute
if (!dataObject.Environment.Errors.Any())
// ReSharper restore AssignNullToNotNullAttribute
{
JsonMappings.ToList().ForEach(m =>
{
var validationResult = new IsValidJsonCreateMappingInputRule(() => m).Check();
if (validationResult != null)
{
dataObject.Environment.AddError(validationResult.Message);
}
});
}
if (dataObject.IsDebugMode())
{
int j = 0;
// ReSharper disable PossibleNullReferenceException
foreach (JsonMappingTo a in JsonMappings.Where(to => !String.IsNullOrEmpty(to.SourceName)))
// ReSharper restore PossibleNullReferenceException
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams(string.Empty, (++j).ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugEvalResult(a.SourceName, string.Empty, dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
}
// TODO: More validation through IRule, IRuleSet to throw out anything not in spec
if (!dataObject.Environment.Errors.Any())
{
// JsonMappings.Count() is larger than zero
var json = new JObject(); // outermost JSON would always be a single JObject, i.e. {'name': value}
// ReSharper disable AssignNullToNotNullAttribute
List <JsonMappingTo> jsonMappingList = JsonMappings.ToList();
// ReSharper restore AssignNullToNotNullAttribute
// build the list of JsonMappingCompoundTo - a compound is either a single expression or a comma seperated list of expressions
// ReSharper disable MaximumChainedReferences
List <JsonMappingCompoundTo> results = jsonMappingList.Where(to => !String.IsNullOrEmpty(to.SourceName)).Select(jsonMapping =>
new JsonMappingCompoundTo(dataObject.Environment, jsonMapping
)).ToList();
// ReSharper restore MaximumChainedReferences
// main loop for producing largest list of zipped values
results.ForEach(x =>
{
// if it is not a compound,
if (!x.IsCompound)
{
// add JProperty, with name x.DestinationName, and value eval(x.SourceName)
json.Add(new JProperty(
x.DestinationName,
x.EvaluatedResultIndexed(0))
);
}
else
{
// if it is a compound,
if (!x.EvalResult.IsWarewolfRecordSetResult)
{
json.Add(new JProperty(
x.DestinationName,
x.ComplexEvaluatedResultIndexed(0))
);
}
else if (x.EvalResult.IsWarewolfRecordSetResult)
{
json.Add(
x.ComplexEvaluatedResultIndexed(0));
}
}
}
);
dataObject.Environment.Assign(JsonString, json.ToString(Formatting.None), update);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugEvalResult(JsonString, string.Empty, dataObject.Environment, update));
}
/*
* var rule = new IsSingleValueRule(() => CountNumber);
* var single = rule.Check();
* if (single != null)
* {
* allErrors.AddError(single.Message);
* }
* else
* {
* var count = 0;
* if (dataObject.Environment.HasRecordSet(RecordsetName))
* {
* count = dataObject.Environment.GetCount(rs);
* }
* var value = count.ToString();
* dataObject.Environment.Assign(CountNumber, value);
* AddDebugOutputItem(new DebugEvalResult(CountNumber, "", dataObject.Environment));
* }
* */
}
}
catch (Exception e)
{
// ReSharper disable AssignNullToNotNullAttribute
JsonMappings.ToList().ForEach(x =>
// ReSharper restore AssignNullToNotNullAttribute
{
AddDebugInputItem(new DebugItemStaticDataParams("", x.SourceName, "SourceName", "="));
AddDebugInputItem(new DebugItemStaticDataParams("", x.DestinationName, "DestinationName"));
});
allErrors.AddError(e.Message);
dataObject.Environment.Assign(JsonString, string.Empty, update);
AddDebugOutputItem(new DebugItemStaticDataParams(string.Empty, JsonString, "", "="));
}
finally
{
// Handle Errors
bool hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCreateJsonActivity", allErrors);
string errorString = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, IPrincipal user = null)
{
//lock(ExecutionObject)
{
string executePayload = "";
Guid workspaceGuid;
if (workspaceId != null)
{
if (!Guid.TryParse(workspaceId, out workspaceGuid))
{
workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID;
}
}
else
{
workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID;
}
var allErrors = new ErrorResultTO();
var dataObject = new DsfDataObject(webRequest.RawRequestPayload, GlobalConstants.NullDataListID, webRequest.RawRequestPayload)
{
IsFromWebServer = true, ExecutingUser = user, ServiceName = serviceName, WorkspaceID = workspaceGuid
};
// now bind any variables that are part of the path arguments ;)
BindRequestVariablesToDataObject(webRequest, ref dataObject);
// now process headers ;)
if (headers != null)
{
Dev2Logger.Log.Debug("Remote Invoke");
var isRemote = headers.Get(HttpRequestHeader.Cookie.ToString());
var remoteId = headers.Get(HttpRequestHeader.From.ToString());
if (isRemote != null && remoteId != null)
{
if (isRemote.Equals(GlobalConstants.RemoteServerInvoke))
{
// we have a remote invoke ;)
dataObject.RemoteInvoke = true;
}
if (isRemote.Equals(GlobalConstants.RemoteDebugServerInvoke))
{
// we have a remote invoke ;)
dataObject.RemoteNonDebugInvoke = true;
}
dataObject.RemoteInvokerID = remoteId;
}
}
// now set the emition type ;)
int loc;
if (!String.IsNullOrEmpty(serviceName) && (loc = serviceName.LastIndexOf(".", StringComparison.Ordinal)) > 0)
{
// default it to xml
dataObject.ReturnType = EmitionTypes.XML;
if (loc > 0)
{
var typeOf = serviceName.Substring((loc + 1)).ToUpper();
EmitionTypes myType;
if (Enum.TryParse(typeOf, out myType))
{
dataObject.ReturnType = myType;
}
// adjust the service name to drop the type ;)
// avoid .wiz amendments ;)
if (!typeOf.ToLower().Equals(GlobalConstants.WizardExt))
{
serviceName = serviceName.Substring(0, loc);
dataObject.ServiceName = serviceName;
}
if (typeOf.Equals("api", StringComparison.OrdinalIgnoreCase))
{
dataObject.ReturnType = EmitionTypes.SWAGGER;
}
}
}
else
{
// default it to xml
dataObject.ReturnType = EmitionTypes.XML;
}
// ensure service gets set ;)
if (dataObject.ServiceName == null)
{
dataObject.ServiceName = serviceName;
}
IResource resource = null;
if (!String.IsNullOrEmpty(dataObject.ServiceName))
{
resource = ResourceCatalog.Instance.GetResource(dataObject.WorkspaceID, dataObject.ServiceName);
if (resource != null)
{
dataObject.ResourceID = resource.ResourceID;
}
}
var esbEndpoint = new EsbServicesEndpoint();
dataObject.EsbChannel = esbEndpoint;
var canExecute = true;
if (ServerAuthorizationService.Instance != null)
{
var authorizationService = ServerAuthorizationService.Instance;
var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, dataObject.ResourceID.ToString());
var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, dataObject.ResourceID.ToString());
canExecute = (hasExecute && hasView) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource != null && resource.ResourceType == ResourceType.ReservedService);
}
// Build EsbExecutionRequest - Internal Services Require This ;)
EsbExecuteRequest esbExecuteRequest = new EsbExecuteRequest {
ServiceName = serviceName
};
foreach (string key in webRequest.Variables)
{
esbExecuteRequest.AddArgument(key, new StringBuilder(webRequest.Variables[key]));
}
Dev2Logger.Log.Debug("About to execute web request [ " + serviceName + " ] DataObject Payload [ " + dataObject.RawPayload + " ]");
var executionDlid = GlobalConstants.NullDataListID;
if (canExecute && dataObject.ReturnType != EmitionTypes.SWAGGER)
{
ErrorResultTO errors;
executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors);
allErrors.MergeErrors(errors);
}
else if (!canExecute)
{
allErrors.AddError("Executing a service externally requires View and Execute permissions");
}
foreach (var error in dataObject.Environment.Errors)
{
allErrors.AddError(error, true);
}
// Fetch return type ;)
var formatter = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "text/xml");
// force it to XML if need be ;)
// Fetch and convert DL ;)
if (!dataObject.Environment.HasErrors())
{
// a normal service request
if (!esbExecuteRequest.WasInternalService)
{
dataObject.DataListID = executionDlid;
dataObject.WorkspaceID = workspaceGuid;
dataObject.ServiceName = serviceName;
if (!dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke)
{
if (dataObject.ReturnType == EmitionTypes.JSON)
{
formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json");
executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0);
}
else if (dataObject.ReturnType == EmitionTypes.XML)
{
executePayload = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, Guid.Empty, resource.DataList.ToString(), 0);
}
else if (dataObject.ReturnType == EmitionTypes.SWAGGER)
{
formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json");
executePayload = ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource, resource.DataList.ToString());
}
}
else
{
executePayload = string.Empty;
}
}
else
{
// internal service request we need to return data for it from the request object ;)
var serializer = new Dev2JsonSerializer();
executePayload = string.Empty;
var msg = serializer.Deserialize <ExecuteMessage>(esbExecuteRequest.ExecuteResult);
if (msg != null)
{
executePayload = msg.Message.ToString();
}
// out fail safe to return different types of data from services ;)
if (string.IsNullOrEmpty(executePayload))
{
executePayload = esbExecuteRequest.ExecuteResult.ToString();
}
}
}
else
{
if (dataObject.ReturnType == EmitionTypes.XML)
{
executePayload =
"<FatalError> <Message> An internal error occurred while executing the service request </Message>";
executePayload += allErrors.MakeDataListReady();
executePayload += "</FatalError>";
}
else
{
// convert output to JSON ;)
executePayload =
"{ \"FatalError\": \"An internal error occurred while executing the service request\",";
executePayload += allErrors.MakeDataListReady(false);
executePayload += "}";
}
}
Dev2Logger.Log.Debug("Execution Result [ " + executePayload + " ]");
// JSON Data ;)
if (executePayload.IndexOf("</JSON>", StringComparison.Ordinal) >= 0)
{
int start = executePayload.IndexOf(GlobalConstants.OpenJSON, StringComparison.Ordinal);
if (start >= 0)
{
int end = executePayload.IndexOf(GlobalConstants.CloseJSON, StringComparison.Ordinal);
start += GlobalConstants.OpenJSON.Length;
executePayload = CleanupHtml(executePayload.Substring(start, (end - start)));
if (!String.IsNullOrEmpty(executePayload))
{
return(new StringResponseWriter(executePayload, ContentTypes.Json));
}
}
}
Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObject.DataListID);
dataObject.Environment = null;
return(new StringResponseWriter(executePayload, formatter.ContentType));
}
}
public void ErrorResultTO_AddError_CheckForDuplicates_False_AddSameError_ExpectAdd()
{
var resultTo = new ErrorResultTO();
resultTo.AddError("some message", false);
resultTo.AddError("some message", false);
resultTo.AddError("some message", true);
resultTo.AddError("deferent message", false);
Assert.IsTrue(resultTo.HasErrors());
Assert.AreEqual(2, resultTo.FetchErrors().Count);
Assert.AreEqual("some message", resultTo.FetchErrors()[0]);
Assert.AreEqual("deferent message", resultTo.FetchErrors()[1]);
Assert.AreEqual("<InnerError>some message</InnerError><InnerError>deferent message</InnerError>", resultTo.MakeDataListReady());
}
// 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>
/// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity
/// </summary>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(executionId);
}
IFunctionEvaluator functionEvaluator = MathOpsFactory.CreateFunctionEvaluator();
string input = string.IsNullOrEmpty(Expression) ? Expression : Expression.Replace("\\r", string.Empty).Replace("\\n", string.Empty).Replace(Environment.NewLine, "");
IEvaluationFunction evaluationFunctionTo = MathOpsFactory.CreateEvaluationExpressionTO(input);
string result = functionEvaluator.EvaluateFunction(evaluationFunctionTo, executionId, out errors);
allErrors.MergeErrors(errors);
compiler.Upsert(executionId, Result, result, out errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(Result, executionId);
}
allErrors.MergeErrors(errors);
}
catch (Exception ex)
{
Dev2Logger.Log.Error("Calculate Exception", ex);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCalculateActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(Result, executionId);
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}