Func <DataStorage.WarewolfAtom, DataStorage.WarewolfAtom> TryConvertFunc(BaseConvertTO item, IExecutionEnvironment env, int update) => a =>
{
var from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType)));
var to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType)));
var broker = _fac.CreateBroker(@from, to);
var value = a.ToString();
if (a.IsNothing)
{
throw new Exception(string.Format(ErrorResource.NullScalarValue, item.FromExpression));
}
if (String.IsNullOrEmpty(value))
{
return(DataStorage.WarewolfAtom.NewDataString(""));
}
var upper = broker.Convert(value);
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
if (evalled is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult warewolfAtomResult)
{
return(warewolfAtomResult.Item);
}
return(DataStorage.WarewolfAtom.Nothing);
}
return(DataStorage.WarewolfAtom.NewDataString(CommonFunctions.evalResultToString(evalled)));
};
public void BaseConvertViewModel_Constructor_PropertiesInitialized()
{
//------------Setup for test--------------------------
var items = new List <BaseConvertTO>
{
new BaseConvertTO("xxxx", "Text", "Binary", "", 1),
new BaseConvertTO("yyyy", "Text", "Text", "", 2)
};
//------------Execute Test---------------------------
var viewModel = new BaseConvertDesignerViewModel(CreateModelItem(items));
viewModel.Validate();
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.ModelItem);
Assert.IsNotNull(viewModel.ModelItemCollection);
Assert.AreEqual("ConvertCollection", viewModel.CollectionName);
var expectedOptions = Dev2EnumConverter.ConvertEnumsTypeToStringList <enDev2BaseConvertType>().ToList();
CollectionAssert.AreEqual(expectedOptions, viewModel.ConvertTypes.ToList());
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
Assert.IsTrue(viewModel.HasLargeView);
}
public FormatNumberDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarHelpToggle();
RoundingTypes = new List <string>(Dev2EnumConverter.ConvertEnumsTypeToStringList <enRoundingType>());
SelectedRoundingType = string.IsNullOrEmpty(RoundingType) ? RoundingTypes[0] : RoundingType;
}
public ForeachDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarHelpToggle();
ForeachTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enForEachType>();
SelectedForeachType = Dev2EnumConverter.ConvertEnumValueToString(ForEachType);
}
public void SelectAndApplyActivity_SetupExecute_GivenNumberFormatTool_ToCorrectFormat()
{
var activity = new DsfNumberFormatActivity
{
Expression = "[[result]]",
Result = "[[result]]",
RoundingType = Dev2EnumConverter.ConvertEnumValueToString(enRoundingType.Up),
RoundingDecimalPlaces = "2",
DecimalPlacesToShow = "2"
};
//------------Setup for test--------------------------
SetupArgumentsForFormatNumber("", "", activity);
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var ages = DataObject.Environment.EvalAsListOfStrings("[[Person(*).Age]]", 0);
Assert.AreEqual("5.27", ages[0]);
Assert.AreEqual("2.30", ages[1]);
Assert.AreEqual("1.00", ages[2]);
Assert.AreEqual("-3.46", ages[3]);
Assert.AreEqual("0.88", ages[4]);
}
Func <DataASTMutable.WarewolfAtom, DataASTMutable.WarewolfAtom> TryConvertFunc(BaseConvertTO item, IExecutionEnvironment env, int update)
{
return(a =>
{
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);
var value = a.ToString();
if (a.IsNothing)
{
throw new Exception(string.Format("Scalar value {{{0}}} is NULL", item.FromExpression));
}
if (String.IsNullOrEmpty(value))
{
return DataASTMutable.WarewolfAtom.NewDataString("");
}
var upper = broker.Convert(value);
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
var warewolfAtomResult = evalled as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (warewolfAtomResult != null)
{
return warewolfAtomResult.Item;
}
return DataASTMutable.WarewolfAtom.Nothing;
}
return DataASTMutable.WarewolfAtom.NewDataString(WarewolfDataEvaluationCommon.EvalResultToString(evalled));
});
}
public void Dev2EnumConverter_GetEnumFromStringDiscription_WhenTypeIsNotEnum_ExpectInvalidOperationException()
{
//----------------------Arrange-------------------------
//----------------------Act-----------------------------
//----------------------Assert--------------------------
Assert.ThrowsException <InvalidOperationException>(() => Dev2EnumConverter.GetEnumFromStringDiscription("Up", typeof(object)));
}
public RandomDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarHelpToggle();
RandomTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enRandomType>();
SelectedRandomType = Dev2EnumConverter.ConvertEnumValueToString(RandomType);
}
public ScriptDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarHelpToggle();
ScriptTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enScriptType>();
SelectedScriptType = Dev2EnumConverter.ConvertEnumValueToString(ScriptType);
}
static void OnSelectedRandomTypeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var viewModel = (RandomDesignerViewModel)d;
var value = e.NewValue as string;
if (!string.IsNullOrWhiteSpace(value))
{
switch (value)
{
case "GUID":
viewModel.IsLengthPath = false;
viewModel.Visibility = Visibility.Hidden;
viewModel.LengthContent = "Length";
break;
case "Numbers":
viewModel.IsLengthPath = false;
viewModel.Visibility = Visibility.Visible;
viewModel.LengthContent = "Range";
break;
default:
viewModel.IsLengthPath = true;
viewModel.Visibility = Visibility.Hidden;
viewModel.LengthContent = "Length";
break;
}
viewModel.RandomType = (enRandomType)Dev2EnumConverter.GetEnumFromStringDiscription(value, typeof(enRandomType));
}
}
public FormatNumberDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
RoundingTypes = new List <string>(Dev2EnumConverter.ConvertEnumsTypeToStringList <enRoundingType>());
SelectedRoundingType = string.IsNullOrEmpty(RoundingType) ? RoundingTypes[0] : RoundingType;
AddTitleBarLargeToggle();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Utility_Format_Number;
}
public RandomDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
RandomTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enRandomType>();
SelectedRandomType = Dev2EnumConverter.ConvertEnumValueToString(RandomType);
AddTitleBarLargeToggle();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Utility_Random;
}
public void ScriptDesignerViewModel_Constructor_PropertiesInitialized()
{
var modelItem = CreateModelItem();
var viewModel = new TestScriptDesignerViewModel(modelItem);
var expected = Dev2EnumConverter.ConvertEnumsTypeToStringList <enScriptType>();
CollectionAssert.AreEqual(expected.ToList(), viewModel.ScriptTypes.ToList());
}
public ForeachDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
ForeachTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enForEachType>();
SelectedForeachType = Dev2EnumConverter.ConvertEnumValueToString(ForEachType);
AddTitleBarLargeToggle();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_LoopConstruct_For_Each;
}
public void RandomDesignerViewModel_Constructor_ModelItemIsValid_RandomTypesHasThreeItems()
{
var modelItem = CreateModelItem();
var viewModel = new TestRandomDesignerViewModel(modelItem);
var expected = Dev2EnumConverter.ConvertEnumsTypeToStringList <enRandomType>();
CollectionAssert.AreEqual(expected.ToList(), viewModel.RandomTypes.ToList());
}
public FormatNumberTO(string number, enRoundingType roundingType, int roundingDecimalPlaces,
bool adjustDecimalPlaces, int decimalPlacesToShow)
{
Number = "'" + number + "'";
RoundingType = Dev2EnumConverter.ConvertEnumValueToString(roundingType);
RoundingDecimalPlaces = roundingDecimalPlaces;
AdjustDecimalPlaces = adjustDecimalPlaces;
DecimalPlacesToShow = decimalPlacesToShow;
}
public void Dev2EnumConverter_GetEnumFromStringDiscription_WhenDiscriptionIsNotMacthedInEnum_IsNull_ExpectTrue()
{
//----------------------Arrange-------------------------
//----------------------Act-----------------------------
var convertEnumValueToString = Dev2EnumConverter.GetEnumFromStringDiscription("TestDiscription", typeof(enRoundingType));
//----------------------Assert--------------------------
Assert.IsNull(convertEnumValueToString);
}
public void Dev2EnumConverter_GetEnumFromStringDiscription_WhenDiscriptionIsMacthedInEnum_AreEqual_ExpectTrue()
{
//----------------------Arrange-------------------------
var discription = "Up";
//----------------------Act-----------------------------
var convertEnumValueToString = Dev2EnumConverter.GetEnumFromStringDiscription(discription, typeof(enRoundingType));
//----------------------Assert--------------------------
Assert.AreEqual(discription, convertEnumValueToString.ToString());
}
public BaseConvertDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarQuickVariableInputToggle();
AddTitleBarLargeToggle();
dynamic mi = ModelItem;
InitializeItems(mi.ConvertCollection);
ConvertTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enDev2BaseConvertType>();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Data_Base_Convert;
}
public BaseConvertDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarQuickVariableInputToggle();
AddTitleBarHelpToggle();
dynamic mi = ModelItem;
InitializeItems(mi.ConvertCollection);
ConvertTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enDev2BaseConvertType>();
}
static void OnSelectedCompressionRatioDescriptionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs args)
{
var viewModel = (ZipDesignerViewModel)d;
var description = args.NewValue as string;
var enumValue = Dev2EnumConverter.GetEnumFromStringDiscription(description, typeof(CompressionRatios));
if (enumValue != null)
{
viewModel.CompressionRatio = enumValue.ToString();
}
}
void CbxLoad(object sender, RoutedEventArgs e)
{
ComboBox cbx = sender as ComboBox;
if (cbx != null)
{
if (cbx.Items.Count == 0)
{
cbx.ItemsSource = Dev2EnumConverter.ConvertEnumsTypeToStringList <enDev2BaseConvertType>();
}
}
}
public ScriptDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
_eventPublisher = EventPublishers.Aggregator;
_eventPublisher.Subscribe(this);
EscapeScript = true;
ScriptTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enScriptType>();
SelectedScriptType = Dev2EnumConverter.ConvertEnumValueToString(ScriptType);
ChooseScriptSourceCommand = new DelegateCommand(o => ChooseScriptSources());
AddTitleBarLargeToggle();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Scripting_Script;
}
public ZipDesignerViewModel(ModelItem modelItem)
: base(modelItem, "File or Folder", "Destination")
{
AddTitleBarLargeToggle();
CompressionRatioList = Dev2EnumConverter.ConvertEnumsTypeToStringList <CompressionRatios>();
var selectionRatio = string.IsNullOrEmpty(CompressionRatio)
? CompressionRatios.Default
: (CompressionRatios)Enum.Parse(typeof(CompressionRatios), CompressionRatio);
SelectedCompressionRatioDescription = selectionRatio.GetDescription();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_File_Zip;
}
public void Dev2EnumConverter_ConvertEnumsTypeToStringList_GetType_AreEqual_ExpectTrue()
{
//----------------------Arrange-------------------------
var testList = new List <string>();
testList.Add("None");
testList.Add("Normal");
testList.Add("Up");
testList.Add("Down");
//----------------------Act-----------------------------
var convertEnumsTypeToStringList = Dev2EnumConverter.ConvertEnumsTypeToStringList <enRoundingType>();
//----------------------Assert--------------------------
Assert.AreEqual(testList.GetType(), convertEnumsTypeToStringList.GetType());
}
static enDev2ColumnArgumentDirection GetDev2ColumnArgumentDirection(XmlNode tmpNode)
{
XmlAttribute ioDirectionAttribute = tmpNode.Attributes[GlobalConstants.DataListIoColDirection];
enDev2ColumnArgumentDirection ioDirection;
if (ioDirectionAttribute != null)
{
ioDirection = (enDev2ColumnArgumentDirection)Dev2EnumConverter.GetEnumFromStringDiscription(ioDirectionAttribute.Value, typeof(enDev2ColumnArgumentDirection));
}
else
{
ioDirection = enDev2ColumnArgumentDirection.Both;
}
return(ioDirection);
}
public void SelectAndApplyActivity_SetupExecute_GivenNumberFormatTool_ToCorrectFormat_ComplexObjects()
{
var activity = new DsfNumberFormatActivity
{
Expression = "[[result]]",
Result = "[[result]]",
RoundingType = Dev2EnumConverter.ConvertEnumValueToString(enRoundingType.Up),
RoundingDecimalPlaces = "2",
DecimalPlacesToShow = "2"
};
//------------Setup for test--------------------------
//SetupArgumentsForFormatNumber("", "", activity);
DataObject.Environment = new ExecutionEnvironment();
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "5.2687454"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "2.3"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "1"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "-3.4554"), 0);
DataObject.Environment.AssignJson(new AssignValue("[[@Person().Age]]", "0.875768"), 0);
const string dataSource = "[[@Person(*).Age]]";
const string alias = "[[result]]";
DsfSelectAndApplyActivity dsfSelectAndApplyActivity = new DsfSelectAndApplyActivity
{
DataSource = dataSource,
Alias = alias,
//ApplyActivity = activity
};
dsfSelectAndApplyActivity.ApplyActivityFunc.Handler = activity;
TestStartNode = new FlowStep
{
Action = dsfSelectAndApplyActivity
};
CurrentDl = string.Empty;
TestData = string.Empty;
//------------Execute Test---------------------------
ExecuteProcess(DataObject);
//------------Assert Results-------------------------
var ages = DataObject.Environment.EvalAsListOfStrings("[[@Person(*).Age]]", 0);
Assert.AreEqual("5.27", ages[0]);
Assert.AreEqual("2.30", ages[1]);
Assert.AreEqual("1.00", ages[2]);
Assert.AreEqual("-3.46", ages[3]);
Assert.AreEqual("0.88", ages[4]);
}
public GatherSystemInformationDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarQuickVariableInputToggle();
AddTitleBarHelpToggle();
dynamic mi = ModelItem;
InitializeItems(mi.SystemInformationCollection);
if (mi.SystemInformationCollection == null || mi.SystemInformationCollection.Count <= 0)
{
mi.SystemInformationCollection.Add(new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime, string.Empty, 1));
mi.SystemInformationCollection.Add(new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime, string.Empty, 2));
}
ItemsList = Dev2EnumConverter.ConvertEnumsTypeToStringList <enTypeOfSystemInformationToGather>();
}
public ForeachDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
ForeachTypes = Dev2EnumConverter.ConvertEnumsTypeToStringList <enForEachType>();
SelectedForeachType = Dev2EnumConverter.ConvertEnumValueToString(ForEachType);
AddTitleBarLargeToggle();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_LoopConstruct_For_Each;
var dataFunc = modelItem.Properties["DataFunc"]?.ComputedValue as ActivityFunc <string, bool>;
DataFuncDisplayName = dataFunc?.Handler == null ? "" : dataFunc?.Handler?.DisplayName;
var type = dataFunc?.Handler?.GetType();
if (type != null)
{
DataFuncIcon = ModelItemUtils.GetImageSourceForToolFromType(type);
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(Visibility.Collapsed);
}
var enumValue = Dev2EnumConverter.GetEnumFromStringDiscription(value as string, typeof(enForEachType));
Enum.TryParse((string)parameter, out enForEachType visibleEnumValue);
if (visibleEnumValue.Equals(enumValue))
{
return(Visibility.Visible);
}
return(Visibility.Collapsed);
}
