public void TitleCase_Complex_String_Expected_All_FirstLetterUpperCaseOnAll()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("make.(first)@ 'letter'//cap", "");
IBinaryDataListItem result = converter.TryConvert("Title Case", item);
Assert.AreEqual("Make.(First)@ 'Letter'//Cap", result.TheValue);
}
public void TitleCase_Simple_String_All_Caps_Expected_All_FirstLetterUpperCaseOnAll()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("MAKE FIRST LETTER UPPERCASE", "");
IBinaryDataListItem result = converter.TryConvert("Title Case", item);
Assert.AreEqual("MAKE FIRST LETTER UPPERCASE", result.TheValue);
}
public IBinaryDataListItem TryConvert(string conversionType, IBinaryDataListItem item)
{
Func <string, string> returnedFunc;
IBinaryDataListItem result = Dev2BinaryDataListFactory.CreateBinaryItem("Error Invalid Conversion Type",
GlobalConstants.EvalautionScalar);
if (_convertFunctions.TryGetValue(conversionType, out returnedFunc))
{
if (returnedFunc != null)
{
string tmp = returnedFunc.Invoke(item.TheValue);
if (item.Namespace != string.Empty)
{
result = Dev2BinaryDataListFactory.CreateBinaryItem(tmp, item.Namespace, item.FieldName,
item.ItemCollectionIndex);
}
else
{
result = Dev2BinaryDataListFactory.CreateBinaryItem(tmp, item.FieldName);
}
}
}
return(result);
}
public void UpperFirst_Simple_String_Expected_All_FirstLetterUpperCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("make first letter uppercase", "");
IBinaryDataListItem result = converter.TryConvert("Sentence", item);
Assert.AreEqual("Make first letter uppercase", result.TheValue);
}
public void AllUpper_Complex_String_Expected_All_UpperCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("string.(to)@ 'make' u//ppercase", "");
IBinaryDataListItem result = converter.TryConvert("UPPER", item);
Assert.AreEqual("STRING.(TO)@ 'MAKE' U//PPERCASE", result.TheValue);
}
public void AllUpper_StringContainingNumerics_Expected_All_UpperCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("2strinG 4To 8m9ake upp522erc7ase", "");
IBinaryDataListItem result = converter.TryConvert("UPPER", item);
Assert.AreEqual("2STRING 4TO 8M9AKE UPP522ERC7ASE", result.TheValue);
}
public void AllLower_Simple_String_Expected_All_LowerCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("STRING TO MAKE LOWERCASE", "");
IBinaryDataListItem result = converter.TryConvert("lower", item);
Assert.AreEqual("string to make lowercase", result.TheValue);
}
public void AllLower_StringContainingNumerics_Expected_All_LowerCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("2STRING T4O M6AKE LO08WERCASE", "");
IBinaryDataListItem result = converter.TryConvert("lower", item);
Assert.AreEqual("2string t4o m6ake lo08wercase", result.TheValue);
}
public void TitleCase_StringWithNumeric_Expected_All_FirstLetterUpperCaseOnAll()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("1make fi5rst le6tter up3percase", "");
IBinaryDataListItem result = converter.TryConvert("Title Case", item);
Assert.AreEqual("1make Fi5rst Le6tter Up3percase", result.TheValue);
}
public void UpperFirst_StringContainingNumerics_Expected_All_FirstLetterUpperCase()
{
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem("5make1 1first 3letter up5percase", "");
IBinaryDataListItem result = converter.TryConvert("Sentence", item);
Assert.AreEqual("5make1 1first 3letter up5percase", result.TheValue);
}
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 void BaseConvertRecsetWithStarIndexToBinaryExpectedOutputToCorrectRecords()
{
SetupArguments(
@"<root></root>"
, ActivityStrings.BaseConvert_DLShape.Replace("<ADL>", "<ADL><setup/>")
, new List <BaseConvertTO> {
new BaseConvertTO("", "Text", "Binary", "[[setup]]", 1)
}
);
IDSFDataObject result = ExecuteProcess();
ErrorResultTO errorResult;
IBinaryDataList bdl = Compiler.FetchBinaryDataList(result.DataListID, out errorResult);
IBinaryDataListItem isolatedRecord = Dev2BinaryDataListFactory.CreateBinaryItem("CONVERT THIS TO BINARY", "Field");
string error;
IBinaryDataListEntry entry;
bdl.TryGetEntry("Recset", out entry, out error);
entry.TryPutRecordItemAtIndex(isolatedRecord, 5, out error);
IList <BaseConvertTO> convertCollection = new List <BaseConvertTO> {
new BaseConvertTO("[[Recset(*).Field]]", "Text", "Binary", "[[Recset(*).Field]]", 1)
};
TestStartNode = new FlowStep
{
Action = new DsfBaseConvertActivity {
ConvertCollection = convertCollection
}
};
result = ExecuteProcess();
IList <IBinaryDataListEntry> actual = bdl.FetchRecordsetEntries();
var index = actual[0].FetchRecordAt(5, out error)[0].ItemCollectionIndex;
var count = actual.Count();
var actualValue = actual[0].FetchRecordAt(5, out error)[0].TheValue;
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.AreEqual("01000011010011110100111001010110010001010101001001010100001000000101010001001000010010010101001100100000010101000100111100100000010000100100100101001110010000010101001001011001", actualValue);
Assert.AreEqual(1, count); // still only one record
Assert.AreEqual(5, index); // and that record has not moved
}
public IBinaryDataListItem FetchNextRow(IDev2DataListEvaluateIterator itr)
{
IBinaryDataListItem result = null;
IList <IBinaryDataListItem> tmp;
int idx = _itrCollection.IndexOf(itr);
if (idx >= 0)
{
if (_itrCollection[idx].HasMoreRecords())
{
tmp = _itrCollection[idx].FetchNextRowData();
if (tmp != null)
{
if (tmp.Count == 1)
{
result = tmp[0];
}
else if (tmp.Count == 0)
{
result = Dev2BinaryDataListFactory.CreateBinaryItem(string.Empty, string.Empty);
}
else if (tmp.Count > 1)
{
throw new Exception("Invalid use, iterator collection may only return a single column per row");
}
}
}
else
{
tmp = _itrCollection[idx].FetchNextRowData();
if (tmp != null)
{
result = tmp[0];
}
}
}
return(result);
}
// internal to impl api methods
private IBinaryDataList ConvertTo(byte[] input, StringBuilder targetShape, out ErrorResultTO errors, bool onlyMapInputs)
{
errors = new ErrorResultTO();
string payload = Encoding.UTF8.GetString(input);
IBinaryDataList result = new BinaryDataList();
TranslatorUtils tu = new TranslatorUtils();
// build shape
if (targetShape == null)
{
errors.AddError("Null payload or shape");
}
else
{
ErrorResultTO invokeErrors;
result = tu.TranslateShapeToObject(targetShape, true, out invokeErrors);
errors.MergeErrors(invokeErrors);
// populate the shape
if (payload != string.Empty)
{
try
{
string toLoad = DataListUtil.StripCrap(payload); // clean up the rubish ;)
XmlDocument xDoc = new XmlDocument();
// BUG 9626 - 2013.06.11 - TWR: ensure our DocumentElement
toLoad = string.Format("<Tmp{0}>{1}</Tmp{0}>", Guid.NewGuid().ToString("N"), toLoad);
xDoc.LoadXml(toLoad);
if (xDoc.DocumentElement != null)
{
XmlNodeList children = xDoc.DocumentElement.ChildNodes;
IDictionary <string, int> indexCache = new Dictionary <string, int>();
// BUG 9626 - 2013.06.11 - TWR: refactored for recursion
TryConvert(children, result, indexCache, errors, onlyMapInputs);
}
// Transfer System Tags
for (int i = 0; i < TranslationConstants.systemTags.Length; i++)
{
string key = TranslationConstants.systemTags.GetValue(i).ToString();
string query = String.Concat("//", key);
XmlNode n = xDoc.SelectSingleNode(query);
// try system namespace tags ;)
if (n == null)
{
var values = "//" + DataListUtil.BuildSystemTagForDataList(key, false);
query = values;
n = xDoc.SelectSingleNode(query);
}
if (n != null && !string.IsNullOrEmpty(n.InnerXml))
{
string bkey = DataListUtil.BuildSystemTagForDataList(key, false);
string error;
IBinaryDataListEntry sysEntry;
if (result.TryGetEntry(bkey, out sysEntry, out error))
{
sysEntry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(n.InnerXml, bkey), out error);
}
}
}
}
catch (Exception e)
{
// if use passed in empty input they only wanted the shape ;)
if (input.Length > 0)
{
errors.AddError(e.Message);
}
}
}
}
return(result);
}
// BUG 9626 - 2013.06.11 - TWR: refactored for recursion
static void TryConvert(XmlNodeList children, IBinaryDataList result, IDictionary <string, int> indexCache, ErrorResultTO errors, bool onlyMapInputs, int level = 0)
{
// spin through each element in the XML
foreach (XmlNode c in children)
{
if (!DataListUtil.IsSystemTag(c.Name) && c.Name != GlobalConstants.NaughtyTextNode)
{
// scalars and recordset fetch
IBinaryDataListEntry entry;
string error;
if (result.TryGetEntry(c.Name, out entry, out error))
{
if (entry.IsRecordset)
{
// fetch recordset index
int fetchIdx;
var idx = indexCache.TryGetValue(c.Name, out fetchIdx) ? fetchIdx : 1;
// process recordset
var nl = c.ChildNodes;
foreach (XmlNode subc in nl)
{
// Extract column being mapped to ;)
var theCol = entry.Columns.FirstOrDefault(col => col.ColumnName == subc.Name);
var dir = enDev2ColumnArgumentDirection.None;
if (theCol != null)
{
dir = theCol.ColumnIODirection;
}
if (CanMapValue(onlyMapInputs, dir))
{
entry.TryPutRecordItemAtIndex(Dev2BinaryDataListFactory.CreateBinaryItem(subc.InnerXml, c.Name, subc.Name, idx), idx, out error);
}
errors.AddError(error);
}
// update this recordset index
indexCache[c.Name] = ++idx;
}
else if (CanMapValue(onlyMapInputs, entry.ColumnIODirection))
{
// process scalar
entry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(c.InnerXml, c.Name), out error);
if (!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
}
}
else
{
if (level == 0)
{
// Only recurse if we're at the first level!!
TryConvert(c.ChildNodes, result, indexCache, errors, onlyMapInputs, ++level);
}
else
{
errors.AddError(error);
}
}
}
}
}
internal static IBinaryDataList BuildBinaryDataList(byte[] input, StringBuilder targetShape, ErrorResultTO errors, string payload)
{
IBinaryDataList result = null;
// build shape
if (targetShape == null)
{
errors.AddError("Null payload or shape");
}
else
{
string error;
result = BuildTargetShape(targetShape, out error);
errors.AddError(error);
// populate the shape
if (payload != String.Empty)
{
try
{
var toLoad = payload;
XmlDocument xDoc = new XmlDocument();
try
{
xDoc.LoadXml(toLoad);
}
catch
{
// Append new root tags ;)
toLoad = "<root>" + toLoad + "</root>";
xDoc.LoadXml(toLoad);
}
if (!String.IsNullOrEmpty(toLoad))
{
if (xDoc.DocumentElement != null)
{
XmlNodeList children = xDoc.DocumentElement.ChildNodes;
IDictionary <string, int> indexCache = new Dictionary <string, int>();
// spin through each element in the XML
foreach (XmlNode c in children)
{
var hasCorrectIoDirection = true;
if (c.Attributes != null)
{
var columnIoDirectionAttribute = c.Attributes["ColumnIODirection"];
if (columnIoDirectionAttribute != null)
{
var columnIoDirectionValue = columnIoDirectionAttribute.Value;
var hasCorrectIoDirectionFromAttribute = columnIoDirectionValue == enDev2ColumnArgumentDirection.Output.ToString() || columnIoDirectionValue == enDev2ColumnArgumentDirection.Both.ToString();
hasCorrectIoDirection = hasCorrectIoDirectionFromAttribute;
}
}
if (DataListUtil.IsSystemTag(c.Name) && !hasCorrectIoDirection)
{
continue;
}
// scalars and recordset fetch
IBinaryDataListEntry entry;
if (result.TryGetEntry(c.Name, out entry, out error))
{
if (entry.IsRecordset)
{
// fetch recordset index
int fetchIdx;
int idx = indexCache.TryGetValue(c.Name, out fetchIdx) ? fetchIdx : 1; // recset index
// process recordset
XmlNodeList nl = c.ChildNodes;
foreach (XmlNode subc in nl)
{
entry.TryPutRecordItemAtIndex(Dev2BinaryDataListFactory.CreateBinaryItem(subc.InnerXml, c.Name, subc.Name, (idx + "")), idx, out error);
errors.AddError(error);
}
// update this recordset index
indexCache[c.Name] = ++idx;
}
else
{
// process scalar
entry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(c.InnerXml, c.Name), out error);
errors.AddError(error);
}
}
else
{
errors.AddError(error);
}
}
}
}
}
catch (Exception e)
{
// if use passed in empty input they only wanted the shape ;)
if (input.Length > 0)
{
errors.AddError(e.Message);
}
}
}
}
return(result);
}
public IBinaryDataList ConvertTo(byte[] input, StringBuilder targetShape, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
var payload = Encoding.UTF8.GetString(input);
IBinaryDataList result = null;
// build shape
if (String.IsNullOrEmpty(targetShape.ToString()))
{
errors.AddError("Null payload shape");
}
else
{
string error;
result = BuildTargetShape(targetShape, out error);
if (!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
// populate the shape
if (payload != string.Empty)
{
try
{
XmlDocument xDoc = new XmlDocument();
xDoc.LoadXml(payload);
if (xDoc.DocumentElement != null)
{
var children = xDoc.DocumentElement.ChildNodes;
IDictionary <string, int> indexCache = new Dictionary <string, int>();
{
// spin through each element in the XML
foreach (XmlNode c in children)
{
if (!DataListUtil.IsSystemTag(c.Name))
{
// scalars and recordset fetch
IBinaryDataListEntry entry;
if (result.TryGetEntry(c.Name, out entry, out error))
{
if (entry.IsRecordset)
{
// fetch recordset index
int fetchIdx;
int idx; // recset index
if (indexCache.TryGetValue(c.Name, out fetchIdx))
{
idx = fetchIdx;
}
else
{
// 28-02-2013 - Sashen.Naidoo
// BUG 9144
// A cache miss does not necessary mean there is nothing in the record set,
// it just means the value isn't in the record set.
idx = indexCache.Count == 0 ? 1 : indexCache.Count;
}
// process recordset
var nl = c.ChildNodes;
foreach (XmlNode subc in nl)
{
entry.TryPutRecordItemAtIndex(Dev2BinaryDataListFactory.CreateBinaryItem(subc.InnerXml, c.Name, subc.Name, idx), idx, out error);
if (!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
// update this recordset index
}
indexCache[c.Name] = ++idx;
}
else
{
// process scalar
entry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(c.InnerXml, c.Name), out error);
if (!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
}
}
else
{
errors.AddError(error);
}
}
}
}
}
// Transfer System Tags
for (var i = 0; i < TranslationConstants.systemTags.Length; i++)
{
var key = TranslationConstants.systemTags.GetValue(i).ToString();
var query = String.Concat("//", key);
var n = xDoc.SelectSingleNode(query);
if (n != null && !string.IsNullOrEmpty(n.InnerXml))
{
var bkey = GlobalConstants.SystemTagNamespace + "." + key;
IBinaryDataListEntry sysEntry;
if (result.TryGetEntry(bkey, out sysEntry, out error))
{
sysEntry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(n.InnerXml, bkey), out error);
}
}
}
}
catch (Exception e)
{
// if use passed in empty input they only wanted the shape ;)
if (input.Length > 0)
{
errors.AddError(e.Message);
}
}
}
}
return(result);
}
public IBinaryDataList ConvertTo(byte[] input, StringBuilder targetShape, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
var payload = Encoding.UTF8.GetString(input);
IBinaryDataList result = null;
// build shape
if(targetShape == null)
{
errors.AddError("Null payload or shape");
}
else
{
ErrorResultTO invokeErrors;
result = _tu.TranslateShapeToObject(targetShape, false, out invokeErrors);
errors.MergeErrors(invokeErrors);
// populate the shape
if(payload != string.Empty)
{
try
{
string toLoad = DataListUtil.StripCrap(payload); // clean up the rubbish ;)
XmlDocument xDoc = new XmlDocument();
try
{
xDoc.LoadXml(toLoad);
}
catch
{
// Append new root tags ;)
toLoad = "<root>" + toLoad + "</root>";
xDoc.LoadXml(toLoad);
}
if(!string.IsNullOrEmpty(toLoad))
{
if(xDoc.DocumentElement != null)
{
XmlNodeList children = xDoc.DocumentElement.ChildNodes;
IDictionary<string, int> indexCache = new Dictionary<string, int>();
IBinaryDataListEntry entry;
string error;
if(children.Count > 0 && !DataListUtil.IsMsXmlBugNode(children[0].Name))
{
#region Process children
// spin through each element in the XML
foreach(XmlNode c in children)
{
var hasCorrectIoDirection = true;
if(c.Attributes != null)
{
var columnIoDirectionAttribute = c.Attributes["ColumnIODirection"];
if(columnIoDirectionAttribute != null)
{
var columnIoDirectionValue = columnIoDirectionAttribute.Value;
var hasCorrectIoDirectionFromAttribute = columnIoDirectionValue == enDev2ColumnArgumentDirection.Output.ToString() || columnIoDirectionValue == enDev2ColumnArgumentDirection.Both.ToString();
hasCorrectIoDirection = hasCorrectIoDirectionFromAttribute;
}
}
if(DataListUtil.IsSystemTag(c.Name) && !hasCorrectIoDirection)
{
continue;
}
// scalars and recordset fetch
if(result.TryGetEntry(c.Name, out entry, out error))
{
if(entry.IsRecordset)
{
// fetch recordset index
int fetchIdx;
int idx = indexCache.TryGetValue(c.Name, out fetchIdx) ? fetchIdx : 1;
// process recordset
XmlNodeList nl = c.ChildNodes;
foreach(XmlNode subc in nl)
{
entry.TryPutRecordItemAtIndex(Dev2BinaryDataListFactory.CreateBinaryItem(subc.InnerXml, c.Name, subc.Name, (idx + "")), idx, out error);
if(!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
}
// update this recordset index
indexCache[c.Name] = ++idx;
}
else
{
entry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(c.InnerXml, c.Name), out error);
if(!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
}
}
else
{
errors.AddError(error);
}
}
#endregion
}
else
{
var c = xDoc.DocumentElement;
if(result.TryGetEntry(c.Name, out entry, out error))
{
entry.TryPutScalar(Dev2BinaryDataListFactory.CreateBinaryItem(c.InnerXml, c.Name), out error);
if(!string.IsNullOrEmpty(error))
{
errors.AddError(error);
}
}
}
}
}
}
catch(Exception e)
{
// if use passed in empty input they only wanted the shape ;)
if(input.Length > 0)
{
errors.AddError(e.Message);
}
}
}
}
return result;
}
