/// <summary>
/// Nearly identical to base, override needed because other classes use road segments
/// </summary>
/// <param name="objectAsDict"></param>
/// <returns></returns>
protected sealed override List <Segment> GetSegmentList(IDictionary <string, object> objectAsDict)
{
if (!objectAsDict.ContainsKey("posList"))
{
return(null);
}
var lineList = (List <string>)objectAsDict["posList"];
var exteriorLine = lineList.First();
if (string.IsNullOrEmpty(exteriorLine))
{
return(null);
}
List <Segment> netSegments = new List <Segment>();
var exteriorLinePoints = TranslatorUtils.LineToVectorList(exteriorLine);
var reductedPoints = DouglasPointsReduction.Reduct(exteriorLinePoints, toleranceDP);
if (reductedPoints.Count <= 1)
{
return(null);
}
for (int i = 0; i < reductedPoints.Count - 1; i++)
{
Segment newSegment = new Segment {
p1 = reductedPoints[i], p2 = reductedPoints[i + 1]
};
netSegments.Add(newSegment);
TranslatorInitiator.GridSegment.Add(newSegment);
}
return(netSegments);
}
protected sealed override HashSet <Vector2> GetPointsInArea(IDictionary <string, object> objectAsDict)
{
if (!isTree && !isPropArea)
{
if (!objectAsDict.ContainsKey("posList"))
{
return(null);
}
var lineList = (List <string>)objectAsDict["posList"];
List <List <Vector2> > lineV2List = new List <List <Vector2> >();
foreach (var line in lineList)
{
var polygon = TranslatorUtils.LineToVectorList(line);
lineV2List.Add(polygon);
}
var avgPoint = Calculations.AvgPoint(lineV2List[0]);
if (!TranslatorUtils.IsNaNVector2(avgPoint))
{
currentPoint = avgPoint;
return(new HashSet <Vector2> {
avgPoint
});
}
}
return(base.GetPointsInArea(objectAsDict));
}
public void TranslatorUtils_TranslateShapeToObject_whenRsBothAndColumnsMixed_FullRSPresentInShape()
{
//------------Setup for test--------------------------
var translatorUtils = new TranslatorUtils();
var shape = new StringBuilder(@"<DataList>
<rs Description="""" IsEditable=""True"" ColumnIODirection=""Both"">
<result Description="""" IsEditable=""True"" ColumnIODirection=""Output"" />
<val Description="""" IsEditable=""True"" ColumnIODirection=""Input"" />
</rs>
</DataList>");
//------------Execute Test---------------------------
ErrorResultTO invokeErrors;
var dl = translatorUtils.TranslateShapeToObject(shape, false, out invokeErrors);
//------------Assert Results-------------------------
IBinaryDataListEntry entry;
string error;
dl.TryGetEntry("rs", out entry, out error);
var keys = dl.FetchAllUserKeys();
Assert.AreEqual(0, invokeErrors.FetchErrors().Count);
Assert.AreEqual(1, keys.Count);
Assert.AreEqual("rs", keys[0]);
Assert.AreEqual("result", entry.Columns[0].ColumnName);
Assert.AreEqual("val", entry.Columns[1].ColumnName);
}
/// <summary>
/// Converts the and filter.
/// </summary>
/// <param name="payload">The payload.</param>
/// <param name="filterShape">The filter shape.</param>
/// <param name="errors">The errors.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">payload</exception>
public StringBuilder ConvertAndFilter(IBinaryDataList payload, StringBuilder filterShape, out ErrorResultTO errors)
{
if (payload == null)
{
throw new ArgumentNullException("payload");
}
int keyCnt = 0;
errors = new ErrorResultTO();
TranslatorUtils tu = new TranslatorUtils();
ErrorResultTO invokeErrors;
IBinaryDataList targetDl = tu.TranslateShapeToObject(filterShape, false, out invokeErrors);
errors.MergeErrors(invokeErrors);
IList <string> itemKeys = targetDl.FetchAllUserKeys();
StringBuilder result = new StringBuilder("{");
foreach (string key in itemKeys)
{
IBinaryDataListEntry entry;
IBinaryDataListEntry tmpEntry;
string error;
if (payload.TryGetEntry(key, out entry, out error) && targetDl.TryGetEntry(key, out tmpEntry, out error))
{
if (entry.IsRecordset)
{
result.Append(ProcessRecordSet(entry, out error));
errors.AddError(error);
}
else
{
result.Append(ProcessScalar(entry));
}
// wack in , for field separator ;)
keyCnt++;
if (keyCnt < itemKeys.Count)
{
result.Append(",");
}
}
errors.AddError(error);
}
result.Append("}");
return(result);
}
protected sealed override string GetOther(IDictionary <string, object> objectAsDict, Vector2 point)
{
if (!isTree && !isPropArea)
{
if (TranslatorInitiator.RoadSegment != null)
{
var angleToSegment = TranslatorUtils.AngleToSegment(TranslatorInitiator.RoadSegment, point);
return(angleToSegment.ToString());
}
return("0");
}
return(isPropArea ? "0" : base.GetOther(objectAsDict, point));
}
public void CanDataListHelperCreateTargetShape()
{
// BuildTargetShape
var targetShape = new StringBuilder("<DataList><result Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" /></DataList>");
ErrorResultTO invokeErrors;
TranslatorUtils tu = new TranslatorUtils();
var dl = tu.TranslateShapeToObject(targetShape, false, out invokeErrors);
var keys = dl.FetchAllUserKeys();
Assert.AreEqual(0, invokeErrors.FetchErrors().Count);
Assert.AreEqual(1, keys.Count);
Assert.AreEqual("result", keys[0]);
}
protected sealed override string GetOther(IDictionary <string, object> objectAsDict, Vector2 point)
{
if (currentXkod == "BUWT06" && TranslatorInitiator.GridSegment != null)
{
//Electricity pole, front to electricity line direction
var angleToSegment = TranslatorUtils.AngleToSegment(TranslatorInitiator.RoadSegment, point) + (float)Math.PI / 2;
return(angleToSegment.ToString());
}
else if (TranslatorInitiator.RoadSegment != null)
{
var angleToSegment = TranslatorUtils.AngleToSegment(TranslatorInitiator.RoadSegment, point);
return(angleToSegment.ToString());
}
return("0");
}
public void BinaryDataList_FetchAllRecordSetKeys_WhenHasScalars_ShouldReturn0()
{
//------------Setup for test--------------------------
// BuildTargetShape
var targetShape = new StringBuilder("<DataList><result Description=\"\" IsEditable=\"True\" ColumnIODirection=\"Output\" /></DataList>");
ErrorResultTO invokeErrors;
TranslatorUtils tu = new TranslatorUtils();
var dl = tu.TranslateShapeToObject(targetShape, false, out invokeErrors);
//------------Execute Test---------------------------
var keys = dl.FetchAllRecordSetKeys();
//------------Assert Results-------------------------
Assert.AreEqual(0, invokeErrors.FetchErrors().Count);
Assert.AreEqual(0, keys.Count);
}
public void BinaryDataList_FetchAllRecordSetKeys_WhenHasRecordSetsOnly_ShouldReturn0()
{
//------------Setup for test--------------------------
// BuildTargetShape
var targetShape = new StringBuilder("<DataList><rs><Col1/><Col2/></rs><rec><Col4/><Col5/></rec></DataList>");
ErrorResultTO invokeErrors;
TranslatorUtils tu = new TranslatorUtils();
var dl = tu.TranslateShapeToObject(targetShape, false, out invokeErrors);
//------------Execute Test---------------------------
var keys = dl.FetchAllRecordSetKeys();
//------------Assert Results-------------------------
Assert.AreEqual(0, invokeErrors.FetchErrors().Count);
Assert.AreEqual(2, keys.Count);
Assert.AreEqual("rs", keys[0]);
Assert.AreEqual("rec", keys[1]);
}
protected override HashSet <Vector2> GetPointsInArea(IDictionary <string, object> objectAsDict)
{
if (!objectAsDict.ContainsKey("posList"))
{
return(null);
}
var lineList = (List <string>)objectAsDict["posList"];
var exteriorV2 = TranslatorUtils.LineToVectorList(lineList[0], CoordinatesCalc.IsInResourceRange);
if (exteriorV2.Count < 3)
{
return(null);
}
var areaMinMax = Calculations.FindMaxMin(exteriorV2);
var points = AdditionalPointsCreation.CreatePointArray(areaMinMax[0], areaMinMax[1], gridDist);
List <List <Vector2> > interiors = new List <List <Vector2> >();
if (lineList.Count > 1)
{
for (int i = 1; i < lineList.Count; i++)
{
interiors.Add(TranslatorUtils.LineToVectorList(lineList[i], CoordinatesCalc.IsInResourceRange));
}
}
HashSet <Vector2> selectedPoints = new HashSet <Vector2>();
foreach (var p in points)
{
if (Calculations.PointInPoly(exteriorV2, p) &&
(interiors == null || !interiors.Any(interior => Calculations.PointInPoly(interior, p))))
{
selectedPoints.Add(p);
}
}
return(selectedPoints);
}
public FileArgParser()
: this(
new Dictionary <string, Func <Configuration, List <IScript> > >()
{
{ "FILE", config => new List <IScript>(config.Args.Select(r => new ExternalScript(new FileInfo(r), TranslatorUtils.GetTranslatorByExtensionType(r)))) },
{ "CHOCOLATEY", config => new List <IScript>() { new ChocolateyPackageManagerScript(config.Args) } },
{ "SCOOP", config => new List <IScript>() { new ScoopPackageManagerScript(config.Args) } },
{ "LITERAL", config => new List <IScript>(config.Args.Select(r => new LiteralScript(config.Args))) },
},
path => File.ReadAllText(path))
{
}
public List <IScript> Parse(string arg)
{
List <IScript> scripts = new List <IScript>();
string[] filePaths = arg.Split(",", StringSplitOptions.RemoveEmptyEntries);
List <ExternalScript> fileScripts = filePaths.Select(f => new ExternalScript(new FileInfo(f), TranslatorUtils.GetTranslatorByExtensionType(f))).ToList();
scripts.AddRange(fileScripts);
return(scripts);
}
public DataListTranslatedPayloadTO ConvertFrom(IBinaryDataList payload, out ErrorResultTO errors)
{
if (payload == null)
{
throw new ArgumentNullException("payload");
}
TranslatorUtils tu = new TranslatorUtils();
StringBuilder result = new StringBuilder("<" + RootTag + ">");
errors = new ErrorResultTO();
var itemKeys = payload.FetchAllKeys();
foreach (string key in itemKeys)
{
IBinaryDataListEntry entry;
string error;
if (payload.TryGetEntry(key, out entry, out error))
{
if (entry.IsRecordset)
{
var idxItr = entry.FetchRecordsetIndexes();
while (idxItr.HasMore() && !entry.IsEmpty())
{
while (idxItr.HasMore())
{
int i = idxItr.FetchNextIndex();
IList <IBinaryDataListItem> rowData = entry.FetchRecordAt(i, out error);
errors.AddError(error);
result.Append("<");
result.Append(entry.Namespace);
result.Append(">");
foreach (IBinaryDataListItem col in rowData)
{
string fName = col.FieldName;
result.Append("<");
result.Append(fName);
result.Append(">");
// Travis.Frisinger 04.02.2013
if (!col.IsDeferredRead)
{
try
{
result.Append(tu.CleanForEmit(col.TheValue));
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
}
else
{
// deferred read, just print the location
result.Append(!string.IsNullOrEmpty(col.TheValue) ? col.FetchDeferredLocation() : string.Empty);
}
result.Append("</");
result.Append(fName);
result.Append(">");
}
result.Append("</");
result.Append(entry.Namespace);
result.Append(">");
}
}
}
else
{
string fName = entry.Namespace;
IBinaryDataListItem val = entry.FetchScalar();
if (val != null)
{
result.Append("<");
result.Append(fName);
result.Append(">");
// Travis.Frisinger 04.02.2013
if (!val.IsDeferredRead)
{
// Dev2System.FormView is our html region, pass it by ;)
try
{
result.Append(!entry.IsManagmentServicePayload ? tu.CleanForEmit(val.TheValue) : val.TheValue);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
}
else
{
// deferred read, just print the location
result.Append(val.FetchDeferredLocation());
}
result.Append("</");
result.Append(fName);
result.Append(">");
}
}
}
}
result.Append("</" + RootTag + ">");
DataListTranslatedPayloadTO tmp = new DataListTranslatedPayloadTO(result.ToString());
return(tmp);
}
// 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);
}
