async private Task Query()
{
_features.Clear();
string where = String.IsNullOrEmpty(_where) ?
$"{ _featureClass.IDFieldName }>{ _lastOid }" :
$"{ _where } and { _featureClass.IDFieldName }>{ _lastOid }";
var postData = $"{ _postData }&orderByFields={ _featureClass.IDFieldName }&where={ where.UrlEncodeWhereClause() }";
var jsonFeatureResponse = await _dataset.TryPostAsync <JsonFeatureResponse>(_queryUrl, postData);
#region Parse Field Types (eg. is Date?)
List <string> dateColumns = new List <string>();
if (_featureClass?.Fields != null)
{
foreach (var field in _featureClass.Fields.ToEnumerable())
{
if (field.type == FieldType.Date)
{
dateColumns.Add(field.name);
}
}
}
#endregion
foreach (var jsonFeature in jsonFeatureResponse.Features)
{
Feature feature = new Feature();
#region Geometry
if (_featureClass.GeometryType == geometryType.Polyline && jsonFeature.Geometry?.Paths != null)
{
Polyline polyline = new Polyline();
for (int p = 0, to = jsonFeature.Geometry.Paths.Length; p < to; p++)
{
Path path = new Path();
var pathsPointsArray = jsonFeature.Geometry.Paths[p];
var dimension = pathsPointsArray.GetLength(1); // 2D 3D 3D+M ?
int pathsPointsArrayLength = (pathsPointsArray.Length / dimension);
for (int multiArrayIndex = 0; multiArrayIndex < pathsPointsArrayLength; multiArrayIndex++)
{
path.AddPoint(ArrayToPoint(pathsPointsArray, multiArrayIndex, dimension));
}
polyline.AddPath(path);
}
feature.Shape = polyline;
}
else if (_featureClass.GeometryType == geometryType.Polygon && jsonFeature.Geometry?.Rings != null)
{
Polygon polygon = new Polygon();
for (int r = 0, to = jsonFeature.Geometry.Rings.Length; r < to; r++)
{
Ring ring = new Ring();
var ringsPointsArray = jsonFeature.Geometry.Rings[r];
var dimension = ringsPointsArray.GetLength(1); // 2D 3D 3D+M ?
int ringsPointsArrayLength = (ringsPointsArray.Length / dimension);
for (int multiArrayIndex = 0; multiArrayIndex < ringsPointsArrayLength; multiArrayIndex++)
{
//Point point = new Point();
//point.X = ringsPointsArray[multiArrayIndex, 0];
//point.Y = ringsPointsArray[multiArrayIndex, 1];
ring.AddPoint(ArrayToPoint(ringsPointsArray, multiArrayIndex, dimension));
}
polygon.AddRing(ring);
}
feature.Shape = polygon;
}
else if (_featureClass.GeometryType == geometryType.Point &&
(jsonFeature.Geometry?.X != null) &&
(jsonFeature.Geometry?.Y != null)
)
{
Point shape = _featureClass.HasM ? new PointM() : new Point();
shape.X = jsonFeature.Geometry.X.Value;
shape.Y = jsonFeature.Geometry.Y.Value;
if (_featureClass.HasZ && jsonFeature.Geometry.Z.HasValue)
{
shape.Z = jsonFeature.Geometry.Z.Value;
}
if (this._featureClass.HasM && jsonFeature.Geometry.M.HasValue)
{
((PointM)shape).M = jsonFeature.Geometry.M.Value;
}
feature.Shape = shape;
}
else if (_featureClass.GeometryType == geometryType.Multipoint &&
jsonFeature.Geometry?.Points != null &&
jsonFeature.Geometry.Points.Length > 0)
{
MultiPoint multiPoint = new MultiPoint();
for (int p = 0, pointCount = jsonFeature.Geometry.Points.Length; p < pointCount; p++)
{
var doubleArray = jsonFeature.Geometry.Points[p];
if (doubleArray.Length >= 2)
{
var point = new Point(doubleArray[0].Value, doubleArray[1].Value);
multiPoint.AddPoint(point);
}
}
feature.Shape = multiPoint;
}
else
{
}
#endregion
#region Properties
if (jsonFeature.Attributes != null)
{
var attribiutes = (IDictionary <string, object>)jsonFeature.Attributes;
foreach (var name in attribiutes.Keys)
{
object value = attribiutes[name];
if (dateColumns.Contains(name))
{
try
{
long esriDate = Convert.ToInt64(value);
DateTime td = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(esriDate);
feature.Fields.Add(new FieldValue(name, td));
}
catch // if date is not a long?!
{
feature.Fields.Add(new FieldValue(name, value?.ToString()));
}
}
else
{
//if (!filter.SuppressResolveAttributeDomains && _domains != null && _domains.ContainsKey(name))
//{
// value = DomainValue(name, value?.ToString());
//}
feature.Fields.Add(new FieldValue(name, value?.ToString()));
}
if (name == _featureClass.IDFieldName)
{
feature.OID = int.Parse(value.ToString());
_lastOid = Math.Max(_lastOid, feature.OID);
}
}
}
#endregion
_features.Add(feature);
}
_hasMore = _lastOid > 0 && jsonFeatureResponse.ExceededTransferLimit;
//_hasMore = false;
}
async public Task <bool> MapRequest(gView.Framework.Carto.IDisplay display)
{
if (_dataset == null)
{
return(false);
}
List <IWebServiceTheme> themes = Themes;
if (themes == null)
{
return(false);
}
#region Check for visible Layers
bool visFound = this.Themes.Where(l => l.Visible).Count() > 0;
if (!visFound)
{
if (_image != null)
{
_image.Dispose();
_image = null;
}
return(true);
}
#endregion Check for visible Layers
var serviceUrl = _dataset.ServiceUrl();
//IServiceRequestContext context = display.Map as IServiceRequestContext;
var jsonExportMap = new JsonExportMap();
if (display?.Envelope != null)
{
var env = display.Envelope;
jsonExportMap.BBox = $"{env.minx.ToDoubleString()},{env.miny.ToDoubleString()},{env.maxx.ToDoubleString()},{env.maxy.ToDoubleString()}";
}
var sRef = display.SpatialReference ?? this.SpatialReference;
if (sRef != null)
{
jsonExportMap.BBoxSRef = sRef.Name.ToLower().Replace("epsg:", "");
}
jsonExportMap.Size = $"{display.iWidth},{display.iHeight}";
var layerIds = this.Themes
.Where(l => l.Visible && (l.Class is IWebFeatureClass || l.Class is IWebRasterClass))
.Select(l =>
{
if (l.Class is IWebFeatureClass)
{
return(((IWebFeatureClass)l.Class).ID);
}
if (l.Class is IWebRasterClass)
{
return(((IWebRasterClass)l.Class).ID);
}
return(String.Empty);
});
jsonExportMap.Layers = $"show:{String.Join(",", layerIds)}";
var urlParameters = SerializeToUrlParameters(jsonExportMap);
var response = await _dataset.TryPostAsync <JsonExportResponse>(
serviceUrl
.UrlAppendPath("export")
.UrlAppendParameters("f=json")
.UrlAppendParameters(urlParameters));
bool hasImage = false;
if (!String.IsNullOrWhiteSpace(response.Href))
{
var bm = WebFunctions.DownloadImage(response.Href);
if (bm != null)
{
hasImage = true;
_image = new GeorefBitmap(bm);
if (response.Extent != null)
{
_image.Envelope = new Envelope(response.Extent.Xmin, response.Extent.Ymin, response.Extent.Xmax, response.Extent.Ymax);
}
_image.SpatialReference = sRef;
}
}
if (!hasImage)
{
if (_image != null)
{
_image.Dispose();
_image = null;
}
return(false);
}
return(true);
return(true);
}