public static InputOutputViewModel CreateInputOutputViewModel(string name, string value, string mapsTo, string defaultValue, bool required, string recordSetName, bool emptyToNull)
{
var inputOutputViewModel =
new InputOutputViewModel(name, value, mapsTo, defaultValue, required, recordSetName, emptyToNull);
return inputOutputViewModel;
}
public object Clone()
{
// ReSharper disable once ObjectCreationAsStatement
// ReSharper disable ObjectCreationAsStatement
new ObjectCloner <IDataListItemModel>();
// ReSharper restore ObjectCreationAsStatement
IInputOutputViewModel result = new InputOutputViewModel(Name, Value, MapsTo, DefaultValue, Required, RecordSetName, EmptyToNull);
return(result);
}
public void InputOutputMappingViewModel_DefaultWithEmptyToNull_Expect_EmptyString()
{
const string name = "vehicleColor";
const string value = "vehicleColor";
const string mapsTo = "testMapsTo";
string defaultValue = string.Empty;
const string recordSetName = "testRecSetName";
const bool required = true;
_inputOutputViewModel = new InputOutputViewModel(name, value, mapsTo, defaultValue, required, recordSetName, false);
string actual = _inputOutputViewModel.DisplayDefaultValue;
Assert.AreEqual(string.Empty, actual);
}
public object Clone()
{
// ReSharper disable once ObjectCreationAsStatement
// ReSharper disable ObjectCreationAsStatement
new ObjectCloner<IDataListItemModel>();
// ReSharper restore ObjectCreationAsStatement
IInputOutputViewModel result = new InputOutputViewModel(Name, Value, MapsTo, DefaultValue, Required, RecordSetName, EmptyToNull);
return result;
}
private void SetInputOutputMappingViewModelFromTestMappingObject(InputOutputViewModelTestObject mappingObject)
{
_inputOutputViewModel = InputOutputViewModelFactory.CreateInputOutputViewModel(mappingObject.Name, mappingObject.Value, mappingObject.MapsTo, mappingObject.DefaultValue, mappingObject.Required, mappingObject.RecordSetName);
}
public void MyTestInitialize()
{
InputOutputViewModelTestObject testObject = new InputOutputViewModelTestObject();
_inputOutputViewModel = new InputOutputViewModel(testObject.Name, testObject.Value, testObject.MapsTo, testObject.DefaultValue, testObject.Required, testObject.RecordSetName);
}
/// <summary>
/// Creates the mapping list.
/// </summary>
/// <param name="mappingDefinitions">The mapping definitions.</param>
/// <param name="parser">The parser.</param>
/// <param name="autoAddBrackets">if set to <c>true</c> [automatic add brackets].</param>
/// <param name="isOutputMapping">if set to <c>true</c> [is output mapping].</param>
/// <param name="fuzzyMatch">The fuzzy match.</param>
/// <returns></returns>
private IList<IInputOutputViewModel> CreateMappingList(string mappingDefinitions, IDev2LanguageParser parser, bool autoAddBrackets, bool isOutputMapping, FuzzyMatchVo fuzzyMatch = null)
{
IList<IInputOutputViewModel> result = new List<IInputOutputViewModel>();
IList<IDev2Definition> concreteDefinitions = parser.ParseAndAllowBlanks(mappingDefinitions);
var masterRecordsetName = string.Empty;
foreach(var def in concreteDefinitions)
{
var injectValue = def.RawValue;
if(!string.IsNullOrEmpty(injectValue) || IsWorkflow)
{
if(autoAddBrackets)
{
// When output mapping we need to replace the recordset name if present with MasterRecordset
//
if(isOutputMapping && def.IsRecordSet && fuzzyMatch != null)
{
var field = DataListUtil.ExtractFieldNameFromValue(injectValue);
if(IsWorkflow)
{
field = def.Name;
}
string recordsetName = fuzzyMatch.FetchMatch(def.Name,def.RecordSetName);
if(!string.IsNullOrEmpty(recordsetName))
{
masterRecordsetName = recordsetName;
}
else
{
// we have no match, use the current mapping value ;)
masterRecordsetName = !IsWorkflow ? DataListUtil.ExtractRecordsetNameFromValue(injectValue) : def.RecordSetName;
}
injectValue = FormatString(masterRecordsetName, field);
}
else
{
if(def.IsRecordSet)
{
if(fuzzyMatch != null)
{
string recordsetName = fuzzyMatch.FetchMatch(def.Name, def.RecordSetName);
masterRecordsetName = !String.IsNullOrEmpty(recordsetName) ? recordsetName : def.RecordSetName;
}
else
{
masterRecordsetName = def.RecordSetName;
}
injectValue = FormatString(masterRecordsetName, def.Name);
}
else
{
injectValue = DataListUtil.AddBracketsToValueIfNotExist(!IsWorkflow ? injectValue : def.Name);
}
}
}
}
else
{
if(!def.IsRecordSet)
{
if(!String.IsNullOrEmpty(def.RawValue) && String.IsNullOrEmpty(SavedInputMapping))
{
injectValue = DataListUtil.AddBracketsToValueIfNotExist(def.Name);
}
}
else
{
if(!isOutputMapping)
{
var field = def.Name;
if(fuzzyMatch != null && def.IsRecordSet)
{
if(string.IsNullOrEmpty(masterRecordsetName))
{
string recordsetName = fuzzyMatch.FetchMatch(def.Name, def.RecordSetName);
masterRecordsetName = !string.IsNullOrEmpty(recordsetName) ? recordsetName : def.RecordSetName;
}
injectValue = DataListUtil.ComposeIntoUserVisibleRecordset(masterRecordsetName,
string.Empty, field);
injectValue = DataListUtil.AddBracketsToValueIfNotExist(injectValue);
}
else
{
if(!String.IsNullOrEmpty(def.RawValue) && String.IsNullOrEmpty(SavedInputMapping))
{
injectValue = FormatString(def.RecordSetName, def.Name);
}
}
}
else
{
if(!String.IsNullOrEmpty(def.RawValue) && String.IsNullOrEmpty(SavedOutputMapping))
{
injectValue = FormatString(def.RecordSetName, def.Name);
}
}
}
}
var injectMapsTo = def.MapsTo;
// no saved mappings add brackets ;)
if(!string.IsNullOrEmpty(injectMapsTo) && string.IsNullOrEmpty(SavedInputMapping))
{
injectMapsTo = DataListUtil.AddBracketsToValueIfNotExist(injectMapsTo);
}
else
{
if(def.IsRecordSet)
{
var tmp = injectValue.Replace("()", "(*)");
injectMapsTo = tmp; // tag it as the same ;)
}
else
{
injectMapsTo = injectValue; // tag it as the same ;)
}
}
// def.RecordSetName -> recordsetName
var viewModel = new InputOutputViewModel(def.Name, injectValue, injectMapsTo, def.DefaultValue, def.IsRequired, def.RecordSetName, def.EmptyToNull);
result.Add(viewModel);
}
return result;
}
public object Clone()
{
IInputOutputViewModel result = new InputOutputViewModel(Name, Value, MapsTo, DefaultValue, Required, RecordSetName, EmptyToNull);
return result;
}