public JsonFeature Map(Feature feature)
{
if (feature == null)
{
return(null);
}
var result = new JsonFeature
{
Name = feature.Name,
Description = feature.Description,
Result = this.resultMapper.Map(feature.Result),
Tags = feature.Tags.ToArray().ToList(),
};
result.FeatureElements.AddRange(feature.FeatureElements.Select(this.MapFeatureElement).ToList());
result.Background = this.scenarioMapper.Map(feature.Background);
if (result.Background != null)
{
result.Background.Feature = result;
}
foreach (var featureElement in result.FeatureElements)
{
featureElement.Feature = result;
}
return(result);
}
public JsonFeature Map(Feature feature)
{
if (feature == null)
{
return null;
}
var result = new JsonFeature
{
Name = feature.Name,
Description = feature.Description,
Result = this.resultMapper.Map(feature.Result),
Tags = feature.Tags.ToArray().ToList(),
};
result.FeatureElements.AddRange(feature.FeatureElements.Select(this.MapFeatureElement).ToList());
result.Background = this.scenarioMapper.Map(feature.Background);
if (result.Background != null)
{
result.Background.Feature = result;
}
foreach (var featureElement in result.FeatureElements)
{
featureElement.Feature = result;
}
return result;
}
public void Map_NullFeature_ReturnsNullJsonFeature()
{
var mapper = CreateMapper();
JsonFeature actual = mapper.Map(null);
Check.That(actual).IsNull();
}
private Feature ToFeature(IFeatureClass fc, JsonFeature jsonFeature)
{
var feature = new Feature();
feature.Shape = jsonFeature.Geometry.ToGeometry();
var attributes = (IDictionary <string, object>)jsonFeature.Attributes;
if (attributes == null)
{
throw new ArgumentException("No features attributes!");
}
for (int f = 0, fieldCount = fc.Fields.Count; f < fieldCount; f++)
{
var field = fc.Fields[f];
if (attributes.ContainsKey(field.name))
{
switch (field.type)
{
case FieldType.ID:
feature.Fields.Add(new FieldValue(field.name, attributes[field.name]));
feature.OID = Convert.ToInt32(attributes[field.name]);
break;
case FieldType.Date:
object val = attributes[field.name];
if (val is string)
{
if (val.ToString().Contains(" "))
{
val = DateTime.ParseExact(val.ToString(), "dd.MM.yyyy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
}
else
{
val = DateTime.ParseExact(val.ToString(), "dd.MM.yyyy", System.Globalization.CultureInfo.InvariantCulture);
}
}
else if (val is long || val is int)
{
long esriDate = Convert.ToInt64(val);
val = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(esriDate);
}
feature.Fields.Add(new FieldValue(field.name, val));
break;
default:
feature.Fields.Add(new FieldValue(field.name, attributes[field.name]));
break;
}
}
}
return(feature);
}
public JsonResult EditFences(Map map, GeoCollection <object> args)
{
Collection <JsonFeature> jsonFeatures = new Collection <JsonFeature>();
LayerOverlay spatialFenceOverlay = (LayerOverlay)map.CustomOverlays["SpatialFenceOverlay"];
InMemoryFeatureLayer spatialFenceLayer = (InMemoryFeatureLayer)spatialFenceOverlay.Layers["SpatialFenceLayer"];
foreach (Feature feature in spatialFenceLayer.InternalFeatures)
{
// Add feature into editOverlay on server side to make sure it's synchronous on client and server side
map.EditOverlay.Features.Add(feature);
// Create feature on client side
JsonFeature jsonFeature = new JsonFeature(feature.Id, feature.GetWellKnownText());
jsonFeatures.Add(jsonFeature);
}
return(Json(jsonFeatures));
}
private void Query(IServiceRequestContext context, bool isFeatureServer = false)
{
try
{
var query = JsonConvert.DeserializeObject <JsonQueryLayer>(context.ServiceRequest.Request);
List <JsonFeature> jsonFeatures = new List <JsonFeature>();
List <JsonFeatureResponse.Field> jsonFields = new List <JsonFeatureResponse.Field>();
string objectIdFieldName = String.Empty;
EsriGeometryType esriGeometryType = EsriGeometryType.esriGeometryAny;
JsonSpatialReference featureSref = null;
using (var serviceMap = context.CreateServiceMapInstance())
{
string filterQuery;
var tableClasses = FindTableClass(serviceMap, query.LayerId.ToString(), out filterQuery);
if (isFeatureServer == true && tableClasses.Count > 1)
{
throw new Exception("FeatureService can't be used with aggregated feature classes");
}
foreach (var tableClass in tableClasses)
{
objectIdFieldName = tableClass.IDFieldName;
if (tableClass is IFeatureClass)
{
esriGeometryType = JsonLayer.ToGeometryType(((IFeatureClass)tableClass).GeometryType);
}
QueryFilter filter;
if (!String.IsNullOrWhiteSpace(query.Geometry))
{
filter = new SpatialFilter();
var jsonGeometry = JsonConvert.DeserializeObject <Rest.Json.Features.Geometry.JsonGeometry>(query.Geometry);
((SpatialFilter)filter).Geometry = jsonGeometry.ToGeometry();
((SpatialFilter)filter).FilterSpatialReference = SRef(query.InSRef);
}
else
{
filter = new QueryFilter();
}
if (query.ReturnCountOnly == true)
{
filter.SubFields = !String.IsNullOrWhiteSpace(tableClass.IDFieldName) ? tableClass.IDFieldName : "*";
}
else
{
filter.SubFields = query.OutFields;
}
filter.WhereClause = query.Where;
if (!String.IsNullOrWhiteSpace(query.OutSRef))
{
filter.FeatureSpatialReference = SRef(query.OutSRef);
}
else if (tableClass is IFeatureClass)
{
filter.FeatureSpatialReference = ((IFeatureClass)tableClass).SpatialReference;
}
if (filter.FeatureSpatialReference != null)
{
try
{
featureSref = new JsonSpatialReference()
{
Wkid = int.Parse(filter.FeatureSpatialReference.Name.Split(':')[1])
};
}
catch { }
}
if (filterQuery != String.Empty)
{
filter.WhereClause = (filter.WhereClause != String.Empty) ?
"(" + filter.WhereClause + ") AND " + filterQuery :
filterQuery;
}
#region Feature Spatial Reference
if (query.OutSRef != null)
{
filter.FeatureSpatialReference = SRef(query.OutSRef);
}
#endregion
var cursor = tableClass.Search(filter);
bool firstFeature = true;
if (cursor is IFeatureCursor)
{
IFeature feature;
IFeatureCursor featureCursor = (IFeatureCursor)cursor;
while ((feature = featureCursor.NextFeature) != null)
{
var jsonFeature = new JsonFeature();
var attributesDict = (IDictionary <string, object>)jsonFeature.Attributes;
if (feature.Fields != null)
{
foreach (var field in feature.Fields)
{
object val = field.Value;
if (val is DateTime)
{
val = Convert.ToInt64(((DateTime)val - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds);
}
attributesDict[field.Name] = val;
if (firstFeature)
{
var tableField = tableClass.FindField(field.Name);
if (tableField != null)
{
jsonFields.Add(new JsonFeatureResponse.Field()
{
Name = tableField.name,
Alias = tableField.aliasname,
Length = tableField.size,
Type = JsonField.ToType(tableField.type).ToString()
});
}
}
}
}
jsonFeature.Geometry = feature.Shape?.ToJsonGeometry();
jsonFeatures.Add(jsonFeature);
firstFeature = false;
}
}
}
}
context.ServiceRequest.Succeeded = true;
if (isFeatureServer)
{
context.ServiceRequest.Response = JsonConvert.SerializeObject(new JsonFeatureServiceQueryResponse()
{
ObjectIdFieldName = objectIdFieldName,
GeometryType = esriGeometryType.ToString(),
SpatialReference = featureSref,
Fields = jsonFields.ToArray(),
Features = jsonFeatures.ToArray()
});
}
else if (query.ReturnCountOnly == true)
{
context.ServiceRequest.Response = JsonConvert.SerializeObject(new JsonFeatureCountResponse()
{
Count = jsonFeatures.Count()
});
}
else
{
context.ServiceRequest.Response = JsonConvert.SerializeObject(new JsonFeatureResponse()
{
GeometryType = esriGeometryType.ToString(),
SpatialReference = featureSref,
Fields = jsonFields.ToArray(),
Features = jsonFeatures.ToArray()
});
}
}
catch (Exception ex)
{
context.ServiceRequest.Succeeded = false;
context.ServiceRequest.Response = JsonConvert.SerializeObject(new JsonError()
{
error = new JsonError.Error()
{
code = -1,
message = ex.Message
}
});
}
}
