public void GoodRequestIsForwarded()
{
var requestReceived = new RequestMessage();
FakeWebsocket w = new FakeWebsocket();
IRequestManager totest = new JsonLayer(w);
totest.OnRequest += (sender, message) => requestReceived = message;
//Test when we receive good data
var synchRequest = new SplitonSynchRequest();
synchRequest.lastUpdated = DateTime.Parse("2000-02-02").JavascriptTicks();
synchRequest.projectId = "projectwq";
synchRequest.toUpdate = new List <UpdatableElement>()
{
GetFakeTransaction(1)
};
var request = new RequestMessage();
request.id = 12;
request.request = synchRequest;
string serializeRequest = JsonConvert.SerializeObject(request);
Write("Simulating a string request from websocket connection ...");
w.SimulateReceived(serializeRequest);
Assert.AreEqual(request.id, requestReceived.id);
Assert.AreEqual(request.request.lastUpdated, requestReceived.request.lastUpdated);
Assert.AreEqual(request.request.projectId, requestReceived.request.projectId);
Assert.AreEqual(request.request.toUpdate, requestReceived.request.toUpdate);
}
private JsonLayer Layer(IServiceMap map, int layerId)
{
var datasetElement = map.MapElements.Where(e => e.ID == layerId).FirstOrDefault();
if (datasetElement == null)
{
throw new Exception("Unknown layer: " + layerId);
}
var tocElement = map.TOC.GetTOCElement(datasetElement as ILayer);
JsonField[] fields = new JsonField[0];
if (datasetElement.Class is ITableClass)
{
fields = ((ITableClass)datasetElement.Class).Fields.ToEnumerable().Select(f =>
{
return(new JsonField()
{
Name = f.name,
Alias = f.aliasname,
Type = JsonField.ToType(f.type).ToString()
});
}).ToArray();
}
JsonExtent extent = null;
if (datasetElement.Class is IFeatureClass && ((IFeatureClass)datasetElement.Class).Envelope != null)
{
extent = new JsonExtent()
{
// DoTo: SpatialReference
Xmin = ((IFeatureClass)datasetElement.Class).Envelope.minx,
Ymin = ((IFeatureClass)datasetElement.Class).Envelope.miny,
Xmax = ((IFeatureClass)datasetElement.Class).Envelope.maxx,
Ymax = ((IFeatureClass)datasetElement.Class).Envelope.maxy
};
}
string type = "Feature Layer";
if (datasetElement.Class is IRasterClass)
{
type = "Raster Layer";
}
return(new JsonLayer()
{
CurrentVersion = Version,
Id = datasetElement.ID,
Name = tocElement != null ? tocElement.Name : datasetElement.Title,
DefaultVisibility = tocElement != null ? tocElement.LayerVisible : true,
MaxScale = tocElement != null && tocElement.Layers.Count() > 0 ? Math.Max(tocElement.Layers[0].MinimumScale > 1 ? tocElement.Layers[0].MinimumScale : 0, 0) : 0,
MinScale = tocElement != null && tocElement.Layers.Count() > 0 ? Math.Max(tocElement.Layers[0].MaximumScale > 1 ? tocElement.Layers[0].MaximumScale : 0, 0) : 0,
Fields = fields,
Extent = extent,
Type = type,
GeometryType = datasetElement.Class is IFeatureClass?JsonLayer.ToGeometryType(((IFeatureClass)datasetElement.Class).GeometryType).ToString() : EsriGeometryType.esriGeometryNull.ToString()
});
}
public void BadMessageIsIgnored()
{
int requestReceived = 0;
string badMessage = "ha ha, not a Json request!";
FakeWebsocket w = new FakeWebsocket();
IRequestManager totest = new JsonLayer(w);
totest.OnRequest += (sender, message) => requestReceived++;
//Test when we receive shitty data
w.SimulateReceived(badMessage);
Assert.AreEqual(0, requestReceived);
}
static void Main(string[] args)
{
logger.Info("Starting application");
projectManager = new ProjectManager(new FilePersister());
IWebsocket connection = new RequestFlickerService("SplitonSync");
IRequestManager requestManager = new JsonLayer(connection);
requestManager.OnRequest += ProducerOnOnRequest;
while (true)
{
Thread.Sleep(300000);
NLog.LogManager.GetCurrentClassLogger().Info("I am still alive!(Providing some infos here...)");
}
}
public static TiledLayer ToTiledLayer(this JsonLayer jsonLayer)
{
var tiledLayer = new TiledLayer();
tiledLayer.Data = jsonLayer.Data;
tiledLayer.Height = jsonLayer.Height;
tiledLayer.Id = jsonLayer.Id;
tiledLayer.Name = jsonLayer.Name;
tiledLayer.Type = jsonLayer.Type;
tiledLayer.Visible = jsonLayer.Visible;
tiledLayer.Width = jsonLayer.Width;
tiledLayer.X = jsonLayer.X;
tiledLayer.Y = jsonLayer.Y;
return(tiledLayer);
}
private string LayerFullname(JsonLayers layers, JsonLayer layer)
{
string name = layer.Name;
while (layer != null && layer.ParentLayer != null)
{
layer = layers.LayerById(layer.ParentLayer.Id);
if (layer != null)
{
if (layer.Type == "Annotation Layer" || layer.Type == "Annotation SubLayer")
{
name = $"{ layer.Name }/{ layer.Name } ({ name })";
}
else
{
name = $"{ layer.Name }/{ name }";
}
}
}
return(name);
}
public bool WriteDrawing(string fileName, Stream fileStream, Drawing drawing, ViewPort viewPort, INotifyPropertyChanged fileSettings)
{
var jsonDrawing = new JsonDrawing();
var modelSpace = new JsonBlock()
{
Name = "*Model_Space"
};
jsonDrawing.Floorplan.Blocks.Add(modelSpace);
foreach (var layer in drawing.GetLayers())
{
var jsonLayer = new JsonLayer()
{
Name = layer.Name,
R = layer.Color?.R ?? 0,
G = layer.Color?.G ?? 0,
B = layer.Color?.B ?? 0,
};
jsonDrawing.Floorplan.Layers.Add(jsonLayer);
foreach (var entity in layer.GetEntities())
{
switch (entity.Kind)
{
case EntityKind.Arc:
var arc = (Arc)entity;
var jsonArc = new JsonArc()
{
Layer = layer.Name,
Center = arc.Center,
Radius = arc.Radius,
StartAngle = arc.StartAngle * MathHelper.DegreesToRadians,
EndAngle = arc.EndAngle * MathHelper.DegreesToRadians
};
modelSpace.Entities.Add(jsonArc);
break;
case EntityKind.Line:
var line = (Line)entity;
var jsonLine = new JsonLine()
{
Layer = layer.Name
};
jsonLine.Points.Add(line.P1);
jsonLine.Points.Add(line.P2);
modelSpace.Entities.Add(jsonLine);
break;
}
}
foreach (var jsonEntity in modelSpace.Entities)
{
jsonEntity.BeforeWrite();
}
}
var json = JsonConvert.SerializeObject(jsonDrawing, Settings);
using (var writer = new StreamWriter(fileStream, encoding: Encoding.UTF8, bufferSize: 1024, leaveOpen: true))
{
writer.Write(json);
}
return(true);
}
async static internal Task <GeoServicesFeatureClass> CreateAsync(GeoServicesDataset dataset, JsonLayer jsonLayer)
{
var featureClass = new GeoServicesFeatureClass();
featureClass._dataaset = dataset;
featureClass.ID = jsonLayer.Id.ToString();
featureClass.Name = jsonLayer.Name;
var fields = featureClass.Fields as Fields;
if (fields != null && jsonLayer.Fields != null)
{
foreach (var jsonField in jsonLayer.Fields)
{
var fieldType = RestHelper.FType(jsonField.Type);
if (fieldType == FieldType.String)
{
fields.Add(new Field(jsonField.Name, fieldType, 1024)
{
aliasname = jsonField.Alias ?? jsonField.Name
});
}
else
{
fields.Add(new Field(jsonField.Name, fieldType)
{
aliasname = jsonField.Alias ?? jsonField.Name
});
}
if (fieldType == FieldType.ID)
{
featureClass.IDFieldName = jsonField.Name;
}
}
}
featureClass.GeometryType = jsonLayer.GetGeometryType();
if (jsonLayer.Extent != null)
{
featureClass.Envelope = new Envelope(jsonLayer.Extent.Xmin,
jsonLayer.Extent.Ymin,
jsonLayer.Extent.Xmax,
jsonLayer.Extent.Ymax);
}
featureClass.SpatialReference = await dataset.GetSpatialReference();
return(featureClass);
}
public Task <bool> WriteDrawing(string fileName, Stream fileStream, Drawing drawing, ViewPort viewPort, object fileSettings)
{
var jsonDrawing = new JsonDrawing();
var modelSpace = new JsonBlock()
{
Name = "*Model_Space"
};
jsonDrawing.Floorplan.Blocks.Add(modelSpace);
foreach (var layer in drawing.GetLayers())
{
var jsonLayer = new JsonLayer()
{
Name = layer.Name,
R = layer.Color?.R ?? 0,
G = layer.Color?.G ?? 0,
B = layer.Color?.B ?? 0,
};
jsonDrawing.Floorplan.Layers.Add(jsonLayer);
foreach (var entity in layer.GetEntities())
{
entity.DoEntity(
aggregate => { },
arc => modelSpace.Entities.Add(new JsonArc()
{
Layer = layer.Name,
Center = arc.Center,
Radius = arc.Radius,
StartAngle = arc.StartAngle * MathHelper.DegreesToRadians,
EndAngle = arc.EndAngle * MathHelper.DegreesToRadians
}),
circle => { },
ellipse => { },
image => { },
line =>
{
var jsonLine = new JsonLine()
{
Layer = layer.Name
};
jsonLine.Points.Add(line.P1);
jsonLine.Points.Add(line.P2);
modelSpace.Entities.Add(jsonLine);
},
location => { },
polyline => { },
spline => { },
text => { }
);
}
foreach (var jsonEntity in modelSpace.Entities)
{
jsonEntity.BeforeWrite();
}
}
var json = JsonConvert.SerializeObject(jsonDrawing, Settings);
using (var writer = new StreamWriter(fileStream, encoding: Encoding.UTF8, bufferSize: 1024, leaveOpen: true))
{
writer.Write(json);
}
return(Task.FromResult(true));
}
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
}
});
}
}
