public static bool IsSingleOperand(this enDecisionType decisionType)
{
return
(decisionType == enDecisionType.Choose ||
decisionType == enDecisionType.IsError ||
decisionType == enDecisionType.IsNotError ||
decisionType == enDecisionType.IsNull ||
decisionType == enDecisionType.IsNotNull ||
decisionType == enDecisionType.IsNumeric ||
decisionType == enDecisionType.IsNotNumeric ||
decisionType == enDecisionType.IsText ||
decisionType == enDecisionType.IsNotText ||
decisionType == enDecisionType.IsAlphanumeric ||
decisionType == enDecisionType.IsNotAlphanumeric ||
decisionType == enDecisionType.IsXML ||
decisionType == enDecisionType.IsNotXML ||
decisionType == enDecisionType.IsDate ||
decisionType == enDecisionType.IsNotDate ||
decisionType == enDecisionType.IsEmail ||
decisionType == enDecisionType.IsNotEmail ||
decisionType == enDecisionType.IsRegEx ||
decisionType == enDecisionType.NotRegEx ||
decisionType == enDecisionType.IsBinary ||
decisionType == enDecisionType.IsNotBinary ||
decisionType == enDecisionType.IsHex ||
decisionType == enDecisionType.IsNotHex ||
decisionType == enDecisionType.IsBase64 ||
decisionType == enDecisionType.IsNotBase64
);
}
public static string GetDisplayValue(enDecisionType typeOf)
{
MemberInfo mi = typeof(enDecisionType).GetField(Enum.GetName(typeof(enDecisionType), typeOf));
DecisionTypeDisplayValue attr = (DecisionTypeDisplayValue)Attribute.GetCustomAttribute(mi, typeof(DecisionTypeDisplayValue));
return(attr.DisplayValue);
}
public static void RenderDescription(this enDecisionType decisionType, StringBuilder sb)
{
var name = Enum.GetName(typeof(enDecisionType), decisionType);
var memberInfo = typeof(enDecisionType).GetMember(name).First();
var attribute = memberInfo.GetCustomAttributes(typeof(DecisionTypeDisplayValue), false).First() as DecisionTypeDisplayValue;
sb.Append(attribute.DisplayValue);
}
public static string GetDisplayValue(enDecisionType typeOf)
{
MemberInfo mi = typeof(enDecisionType).GetField(Enum.GetName(typeof(enDecisionType), typeOf));
DecisionTypeDisplayValue attr = (DecisionTypeDisplayValue)Attribute.GetCustomAttribute(mi, typeof(DecisionTypeDisplayValue));
return attr.DisplayValue;
}
public ToolLabelGenerator(enDecisionType evaluationFn, int populatedColumnCount, string col1, string col2, string col3, IExecutionEnvironment env, Dev2DecisionMode mode)
{
this._evaluationFn = evaluationFn;
this._populatedColumnCount = populatedColumnCount;
this._col1 = col1;
this._col2 = col2;
this._col3 = col3;
this._env = env;
this._mode = mode;
}
public void IsBetween_HandlesType_ReturnsIsBetweenType()
{
const enDecisionType DecisionType = enDecisionType.IsBetween;
//------------Setup for test--------------------------
var isBetween = new IsBetween();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual(DecisionType, isBetween.HandlesType());
}
public IDecisionOperation FetchDecisionFunction(enDecisionType typeOf)
{
return(FindMatch(typeOf));
}
// Guid dlID
/// <summary>
/// Executes the decision stack.
/// </summary>
/// <param name="decisionDataPayload">The decision data payload.</param>
/// <param name="oldAmbientData">The old ambient data.</param>
/// <returns></returns>
/// <exception cref="System.Data.InvalidExpressionException">Could not evaluate decision data - No decision function found for [ + typeOf + ]</exception>
public bool ExecuteDecisionStack(string decisionDataPayload, IList <string> oldAmbientData)
{
Guid dlId = FetchDataListID(oldAmbientData);
// if(dlId == GlobalConstants.NullDataListID) throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!");
string newDecisionData = Dev2DecisionStack.FromVBPersitableModelToJSON(decisionDataPayload);
var dds = EvaluateRegion(newDecisionData, dlId);
var env = _environments[dlId];
if (dds != null)
{
if (dlId != GlobalConstants.NullDataListID)
{
try
{
if (dds.TheStack != null)
{
for (int i = 0; i < dds.TotalDecisions; i++)
{
Dev2Decision dd = dds.GetModelItem(i);
enDecisionType typeOf = dd.EvaluationFn;
// Treat Errors special
if (typeOf == enDecisionType.IsError || typeOf == enDecisionType.IsNotError)
{
dd.Col1 = String.Join("", env.Errors);
}
IDecisionOperation op = Dev2DecisionFactory.Instance().FetchDecisionFunction(typeOf);
if (op != null)
{
try
{
bool result = op.Invoke(dds.GetModelItem(i).FetchColsAsArray());
if (!result && dds.Mode == Dev2DecisionMode.AND)
{
// Naughty stuff, we have a false in AND mode... break
return(false);
}
if (result && dds.Mode == Dev2DecisionMode.OR)
{
return(true);
}
}
catch (Exception e)
{
// An error, push into the DL
env.AddError(e.Message);
return(false);
}
}
else
{
throw new InvalidExpressionException("Could not evaluate decision data - No decision function found for [ " + typeOf + " ]");
}
}
// else we are in AND mode and all have passed ;)
if (dds.Mode == Dev2DecisionMode.AND)
{
return(true);
}
//finally, it must be OR mode with no matches ;(
return(false);
}
throw new InvalidExpressionException("Could not evaluate decision data - Invalid model data sent!");
}
catch
{
// all hell has broken loose... ;)
throw new InvalidExpressionException("Could not evaluate decision data - No model data sent!");
}
}
throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!");
}
throw new InvalidExpressionException("Could not populate decision model - DataList Errors!");
}
public IDecisionOperation FetchDecisionFunction(enDecisionType typeOf) => FindMatch(typeOf);
public static string GetFailureMessage(enDecisionType decisionType)
{
// ReSharper disable once RedundantAssignment
string errorMsg = string.Empty;
switch (decisionType)
{
case enDecisionType.Choose:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_Choose;
break;
case enDecisionType.IsError:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsError;
break;
case enDecisionType.IsNotError:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotError;
break;
case enDecisionType.IsNull:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNull;
break;
case enDecisionType.IsNotNull:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotNull;
break;
case enDecisionType.IsNumeric:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNumeric;
break;
case enDecisionType.IsNotNumeric:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotNumeric;
break;
case enDecisionType.IsText:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsText;
break;
case enDecisionType.IsNotText:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotText;
break;
case enDecisionType.IsAlphanumeric:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsAlphanumeric;
break;
case enDecisionType.IsNotAlphanumeric:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotAlphanumeric;
break;
case enDecisionType.IsXML:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsXML;
break;
case enDecisionType.IsNotXML:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotXML;
break;
case enDecisionType.IsDate:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsDate;
break;
case enDecisionType.IsNotDate:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotDate;
break;
case enDecisionType.IsEmail:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsEmail;
break;
case enDecisionType.IsNotEmail:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotEmail;
break;
case enDecisionType.IsRegEx:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsRegEx;
break;
case enDecisionType.NotRegEx:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_NotRegEx;
break;
case enDecisionType.IsEqual:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_Equals;
break;
case enDecisionType.IsNotEqual:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotEqual;
break;
case enDecisionType.IsLessThan:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsLessThan;
break;
case enDecisionType.IsLessThanOrEqual:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsLessThanOrEqual;
break;
case enDecisionType.IsGreaterThan:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsGreaterThan;
break;
case enDecisionType.IsGreaterThanOrEqual:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsGreaterThanOrEqual;
break;
case enDecisionType.IsContains:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsContains;
break;
case enDecisionType.NotContain:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_NotContain;
break;
case enDecisionType.IsEndsWith:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsEndsWith;
break;
case enDecisionType.NotEndsWith:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_NotEndsWith;
break;
case enDecisionType.IsStartsWith:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsStartsWith;
break;
case enDecisionType.NotStartsWith:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_NotStartsWith;
break;
case enDecisionType.IsBetween:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsBetween;
break;
case enDecisionType.NotBetween:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_NotBetween;
break;
case enDecisionType.IsBinary:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsBinary;
break;
case enDecisionType.IsNotBinary:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotBinary;
break;
case enDecisionType.IsHex:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsHex;
break;
case enDecisionType.IsNotHex:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotHex;
break;
case enDecisionType.IsBase64:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsBase64;
break;
case enDecisionType.IsNotBase64:
errorMsg = Warewolf.Resource.Messages.Messages.Test_FailureMessage_IsNotBase64;
break;
}
return(errorMsg);
}
// Guid dlID
/// <summary>
/// Executes the decision stack.
/// </summary>
/// <param name="decisionDataPayload">The decision data payload.</param>
/// <param name="oldAmbientData">The old ambient data.</param>
/// <returns></returns>
/// <exception cref="System.Data.InvalidExpressionException">Could not evaluate decision data - No decision function found for [ + typeOf + ]</exception>
public bool ExecuteDecisionStack(string decisionDataPayload, IList <string> oldAmbientData)
{
// Evaluate decisionDataPayload through the EvaluateFunction ;)
Guid dlId = FetchDataListID(oldAmbientData);
if (dlId == GlobalConstants.NullDataListID)
{
throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!");
}
// Swap out ! with a new internal token to avoid nasty issues with
string newDecisionData = Dev2DecisionStack.FromVBPersitableModelToJSON(decisionDataPayload);
var dds = EvaluateRegion(newDecisionData, dlId);
ErrorResultTO errors = new ErrorResultTO();
if (dds != null)
{
if (dlId != GlobalConstants.NullDataListID)
{
try
{
if (dds.TheStack != null)
{
for (int i = 0; i < dds.TotalDecisions; i++)
{
Dev2Decision dd = dds.GetModelItem(i);
enDecisionType typeOf = dd.EvaluationFn;
// Treat Errors special
if (typeOf == enDecisionType.IsError || typeOf == enDecisionType.IsNotError)
{
dd.Col1 = Compiler.EvaluateSystemEntry(dlId, enSystemTag.Dev2Error, out errors);
}
IDecisionOperation op = Dev2DecisionFactory.Instance().FetchDecisionFunction(typeOf);
if (op != null)
{
try
{
bool result = op.Invoke(dds.GetModelItem(i).FetchColsAsArray());
if (!result && dds.Mode == Dev2DecisionMode.AND)
{
// Naughty stuff, we have a false in AND mode... break
return(false);
}
if (result && dds.Mode == Dev2DecisionMode.OR)
{
return(true);
}
}
catch (Exception e)
{
// An error, push into the DL
ErrorResultTO errorErrors;
errors.AddError(e.Message);
Compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, errors.MakeDataListReady(), out errorErrors);
return(false);
}
}
else
{
throw new InvalidExpressionException("Could not evaluate decision data - No decision function found for [ " + typeOf + " ]");
}
}
// else we are in AND mode and all have passed ;)
if (dds.Mode == Dev2DecisionMode.AND)
{
return(true);
}
//finally, it must be OR mode with no matches ;(
return(false);
}
throw new InvalidExpressionException("Could not evaluate decision data - Invalid model data sent!");
}
catch
{
// all hell has broken loose... ;)
throw new InvalidExpressionException("Could not evaluate decision data - No model data sent!");
}
}
throw new InvalidExpressionException("Could not evaluate decision data - no DataList ID sent!");
}
throw new InvalidExpressionException("Could not populate decision model - DataList Errors!");
}
#pragma warning disable S1541 // Methods and properties should not be too complex
public static string GetFailureMessage(enDecisionType decisionType)
#pragma warning restore S1541 // Methods and properties should not be too complex
{
switch (decisionType)
{
case enDecisionType.Choose: return(Messages.Test_FailureMessage_Choose);
case enDecisionType.IsError: return(Messages.Test_FailureMessage_IsError);
case enDecisionType.IsNotError: return(Messages.Test_FailureMessage_IsNotError);
case enDecisionType.IsNull: return(Messages.Test_FailureMessage_IsNull);
case enDecisionType.IsNotNull: return(Messages.Test_FailureMessage_IsNotNull);
case enDecisionType.IsNumeric: return(Messages.Test_FailureMessage_IsNumeric);
case enDecisionType.IsNotNumeric: return(Messages.Test_FailureMessage_IsNotNumeric);
case enDecisionType.IsText: return(Messages.Test_FailureMessage_IsText);
case enDecisionType.IsNotText: return(Messages.Test_FailureMessage_IsNotText);
case enDecisionType.IsAlphanumeric: return(Messages.Test_FailureMessage_IsAlphanumeric);
case enDecisionType.IsNotAlphanumeric: return(Messages.Test_FailureMessage_IsNotAlphanumeric);
case enDecisionType.IsXML: return(Messages.Test_FailureMessage_IsXML);
case enDecisionType.IsNotXML: return(Messages.Test_FailureMessage_IsNotXML);
case enDecisionType.IsDate: return(Messages.Test_FailureMessage_IsDate);
case enDecisionType.IsNotDate: return(Messages.Test_FailureMessage_IsNotDate);
case enDecisionType.IsEmail: return(Messages.Test_FailureMessage_IsEmail);
case enDecisionType.IsNotEmail: return(Messages.Test_FailureMessage_IsNotEmail);
case enDecisionType.IsRegEx: return(Messages.Test_FailureMessage_IsRegEx);
case enDecisionType.NotRegEx: return(Messages.Test_FailureMessage_NotRegEx);
case enDecisionType.IsEqual: return(Messages.Test_FailureMessage_Equals);
case enDecisionType.IsNotEqual: return(Messages.Test_FailureMessage_IsNotEqual);
case enDecisionType.IsLessThan: return(Messages.Test_FailureMessage_IsLessThan);
case enDecisionType.IsLessThanOrEqual: return(Messages.Test_FailureMessage_IsLessThanOrEqual);
case enDecisionType.IsGreaterThan: return(Messages.Test_FailureMessage_IsGreaterThan);
case enDecisionType.IsGreaterThanOrEqual: return(Messages.Test_FailureMessage_IsGreaterThanOrEqual);
case enDecisionType.IsContains: return(Messages.Test_FailureMessage_IsContains);
case enDecisionType.NotContain: return(Messages.Test_FailureMessage_NotContain);
case enDecisionType.IsEndsWith: return(Messages.Test_FailureMessage_IsEndsWith);
case enDecisionType.NotEndsWith: return(Messages.Test_FailureMessage_NotEndsWith);
case enDecisionType.IsStartsWith: return(Messages.Test_FailureMessage_IsStartsWith);
case enDecisionType.NotStartsWith: return(Messages.Test_FailureMessage_NotStartsWith);
case enDecisionType.IsBetween: return(Messages.Test_FailureMessage_IsBetween);
case enDecisionType.NotBetween: return(Messages.Test_FailureMessage_NotBetween);
case enDecisionType.IsBinary: return(Messages.Test_FailureMessage_IsBinary);
case enDecisionType.IsNotBinary: return(Messages.Test_FailureMessage_IsNotBinary);
case enDecisionType.IsHex: return(Messages.Test_FailureMessage_IsHex);
case enDecisionType.IsNotHex: return(Messages.Test_FailureMessage_IsNotHex);
case enDecisionType.IsBase64: return(Messages.Test_FailureMessage_IsBase64);
case enDecisionType.IsNotBase64: return(Messages.Test_FailureMessage_IsNotBase64);
default: return(string.Empty);
}
}
public static bool IsTripleOperand(this enDecisionType decisionType)
{
return
(decisionType == enDecisionType.IsBetween ||
decisionType == enDecisionType.NotBetween);
}
