private async Task CreateAndAddMapPolygonAsync(IReadOnlyList <BasicGeoposition> path, Color fillColor, Color strokeColor, string name, MapLayerItem layer)
{
var newItem = MapElementItemFactoryService.GetMapPolygonItem(name, path, layer, strokeColor, fillColor);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapPolygonItemAsync(newItem);
}
/// <summary>
/// Gets list of all map icons stored in the database.
/// </summary>
/// <returns><b>List</b> containing <b>MapIconItem</b> objects populated with data from database.</returns>
public static async Task <List <MapIconItem> > GetMapIconItemsAsync()
{
var result = new List <MapIconItem>();
using (var cnn = await GetDbConnectionAsync())
{
cnn.Open();
var sqlcommand =
@"SELECT m.Id, m.Name, l.Id, l.Name, g.Altitude, g.Latitude, g.Longitude
FROM ((MapElement m
INNER JOIN Layer l ON m.Layer_Id = l.Id)
INNER JOIN Geoposition g ON m.Id = g.MapElement_Id)
WHERE m.Type='MapIconItem'";
result = cnn.
Query <MapIconItem, MapLayerItem, BasicGeoposition, MapIconItem>(sqlcommand,
(icon, layer, pos) =>
{
var ret = MapElementItemFactoryService.GetMapIconItem(icon.Name, pos, layer, icon.Id);
return(ret);
},
splitOn: "Id,Altitude").ToList();
}
return(result);
}
public async Task DeleteMapElementAsync_DeletesMapElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
},
new BasicGeoposition()
{
Latitude = 6, Longitude = 2
}
};
var insertedPolygon = MapElementItemFactoryService.GetMapPolygonItem("Test polygon", path,
insertedLayer, Color.FromArgb(0, 0, 0, 0), Color.FromArgb(0, 0, 0, 0));
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolygonItemAsync(insertedPolygon);
await DatabaseAccessService.DeleteMapElementAsync(insertedPolygon.Id);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = await DatabaseAccessService.GetMapElementItemsAsync();
Assert.AreEqual(0, queriedMapElementList.Count, $@"Database query for inserted MapElement
returned list with number of entries different than zero.
Expected: 0,
Actual: {queriedMapElementList.Count}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
private async Task CreateAndAddMapIconAsync(BasicGeoposition position, string title, MapLayerItem layer)
{
var pos = new BasicGeoposition()
{
Longitude = position.Longitude, Latitude = position.Latitude
};
var newItem = MapElementItemFactoryService.GetMapIconItem(title, pos, layer);
AddMapElementItem(newItem);
await DatabaseAccessService.InsertMapIconItemAsync(newItem);
}
/// <summary>
/// Gets list of all map polygons stored in the database.
/// </summary>
/// <returns><b>List</b> containing <b>MapPolygonItem</b> objects populated with data from database.</returns>
public static async Task <List <MapPolygonItem> > GetMapPolygonItemsAsync()
{
var result = new List <MapPolygonItem>();
using (var cnn = await GetDbConnectionAsync())
{
cnn.Open();
var sqlcommand =
@"SELECT m.Id, m.Name, m.StrokeColor, m.FillColor, l.Id, l.Name, g.Altitude, g.Latitude, g.Longitude
FROM ((MapElement m
INNER JOIN Layer l ON m.Layer_Id = l.Id)
INNER JOIN Geoposition g ON m.Id = g.MapElement_Id)
WHERE m.Type='MapPolygonItem'";
var anons = new List <TmpMapElementContainer>();
cnn.Query <dynamic, MapLayerItem, BasicGeoposition, int>(sqlcommand,
(polyline, layer, pos) =>
{
if (anons.Count == 0 || anons.Last().Id != polyline.Id)
{
anons.Add(new TmpMapElementContainer()
{
Id = (int)polyline.Id,
Name = polyline.Name,
StrokeColor = StringColorConverter.ArgbStringToColor((string)polyline.StrokeColor),
FillColor = StringColorConverter.ArgbStringToColor((string)polyline.FillColor),
Layer = layer
});
}
anons.Last().Path.Add(pos);
return(0);
},
splitOn: "Id,Altitude").ToList();
for (int i = 0; i < anons.Count; i++)
{
result.Add(MapElementItemFactoryService.GetMapPolygonItem(anons[i].Name, anons[i].Path,
anons[i].Layer, anons[i].StrokeColor,
anons[i].FillColor, anons[i].Id));
}
}
return(result);
}
public void GetMapIconItem_ConstructsMapIconItemCorrectly()
{
var expectName = "TestName";
var expectPosition = new BasicGeoposition()
{
Latitude = 1, Longitude = 2
};
var expectLayer = new MapLayerItem()
{
Id = 3, Name = "TestLayer"
};
int expectId = 4;
var icon = MapElementItemFactoryService.GetMapIconItem(expectName, expectPosition, expectLayer, expectId);
Assert.AreEqual(expectName, icon.Name);
Assert.AreEqual(expectPosition, icon.GetPosition());
Assert.AreEqual(expectLayer, icon.ParentLayer);
Assert.AreEqual(expectId, icon.Id);
}
public void GetMapPolygonItem_ConstructMapPolygonItemCorrectly()
{
var expectName = "TestName";
var expectPath = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 2, Longitude = 3
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
}
};
var expectLayer = new MapLayerItem()
{
Id = 3, Name = "TestLayer"
};
int expectId = 5;
var expectStrokeColor = Color.FromArgb(100, 100, 100, 100);
var expectFillColor = Color.FromArgb(2, 2, 2, 2);
var polygon = MapElementItemFactoryService.GetMapPolygonItem(
expectName, expectPath, expectLayer, expectStrokeColor, expectFillColor, expectId);
Assert.AreEqual(expectName, polygon.Name);
Assert.AreEqual(expectLayer, polygon.ParentLayer);
Assert.AreEqual(expectId, polygon.Id);
Assert.AreEqual(expectStrokeColor, polygon.StrokeColor);
Assert.AreEqual(expectFillColor, polygon.FillColor);
Assert.IsTrue(expectPath.SequenceEqual(polygon.Path));
}
public async Task GetMapElementItemsAsync_ReturnsMapElementListCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
},
new BasicGeoposition()
{
Latitude = 6, Longitude = 2
}
};
var insertedPolygon = MapElementItemFactoryService.GetMapPolygonItem("Test polygon", path,
insertedLayer, Color.FromArgb(0, 0, 0, 0), Color.FromArgb(0, 0, 0, 0));
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolygonItemAsync(insertedPolygon);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = await DatabaseAccessService.GetMapElementItemsAsync();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement
returned list with number of entries different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First() as MapPolygonItem;
Assert.IsNotNull(queriedMapElement, "Map element is null.");
Assert.AreEqual(insertedPolygon.Id, queriedMapElement.Id, $@"Method returned
MapElement with differrent Id.
Expected: {insertedPolygon.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedPolygon.Name, queriedMapElement.Name, $@"Method returned
MapElement with different Name.
Expected: {insertedPolygon.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.ParentLayer.Id, $@"Method returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.ParentLayer.Id}.");
Assert.AreEqual(insertedPolygon.FillColor, queriedMapElement.FillColor, $@"Method returned
MapElement with different fill color.
Expected: {insertedPolygon.FillColor},
Actual: {queriedMapElement.FillColor}.");
Assert.AreEqual(insertedPolygon.StrokeColor, queriedMapElement.StrokeColor, $@"Method returned
MapElement with different stroke color.
Expected: {insertedPolygon.StrokeColor},
Actual: {queriedMapElement.StrokeColor}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
public async Task InsertMapPolylineItemAsync_InsertsMapElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var path = new List <BasicGeoposition>()
{
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
new BasicGeoposition()
{
Latitude = 3, Longitude = 4
}
};
var insertedPolyline = MapElementItemFactoryService.GetMapPolylineItem(
"Test polyline", path, insertedLayer, Color.FromArgb(0, 0, 0, 0), 0.00001);
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapPolylineItemAsync(insertedPolyline);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = (cnn.Query <dynamic>($"SELECT * FROM MapElement WHERE Id={insertedPolyline.Id}")).ToList();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First();
Assert.IsNotNull(queriedMapElement, "Database query for inserted MapElement returned null.");
Assert.AreEqual(insertedPolyline.Id, queriedMapElement.Id, $@"Database query for inserted MapElement returned
MapElement with differrent Id.
Expected: {insertedPolyline.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedPolyline.Name, queriedMapElement.Name, $@"Database query for inserted MapElement returned
MapElement with different Name.
Expected: {insertedPolyline.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.Layer_Id, $@"Database query for inserted MapElement returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.Layer_id}.");
Assert.AreEqual(insertedPolyline.Width, queriedMapElement.Width, $@"Database query for inserted MapElement returned
MapElement with different width.
Expected: {insertedPolyline.Width},
Actual: {queriedMapElement.Width}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
public async Task InsertMapIconItemAsync_InsertsElementCorrectly()
{
var taskSource = new TaskCompletionSource <object>();
// using dispatcher to run the test in ui thread.
// using UITestMethod attribute was umpossible because it
// doesn't support async
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, async() =>
{
try
{
await DatabaseAccessService.DeleteDatabase();
await DatabaseAccessService.CreateDatabaseAsync();
var insertedLayer = new MapLayerItem()
{
Id = 1234124, Name = "Test Layer"
};
var insertedIcon = MapElementItemFactoryService.GetMapIconItem(
"Test Icon",
new BasicGeoposition()
{
Latitude = 1, Longitude = 2
},
insertedLayer,
123);
await DatabaseAccessService.InsertLayerAsync(insertedLayer);
await DatabaseAccessService.InsertMapIconItemAsync(insertedIcon);
using (var cnn = await DatabaseAccessService.GetDbConnectionAsync())
{
cnn.Open();
var queriedMapElementList = (cnn.Query <dynamic>($"SELECT * FROM MapElement WHERE Id={insertedIcon.Id}")).ToList();
Assert.AreEqual(1, queriedMapElementList.Count, $@"Database query for inserted MapElement returned list with number of entries
different than one.
Expected: 1,
Actual: {queriedMapElementList.Count}.");
var queriedMapElement = queriedMapElementList.First();
Assert.IsNotNull(queriedMapElement, "Database query for inserted MapElement returned null.");
Assert.AreEqual(insertedIcon.Id, queriedMapElement.Id, $@"Database query for inserted MapElement returned
MapElement with differrent Id.
Expected: {insertedIcon.Id},
Actual: {queriedMapElement.Id}.");
Assert.AreEqual(insertedIcon.Name, queriedMapElement.Name, $@"Database query for inserted MapElement returned
MapElement with different Name.
Expected: {insertedIcon.Name},
Actual: {queriedMapElement.Name}.");
Assert.AreEqual(insertedLayer.Id, queriedMapElement.Layer_Id, $@"Database query for inserted MapElement returned
MapElement with different parent layer.
Expected: {insertedLayer.Id},
Actual: {queriedMapElement.Layer_id}.");
}
taskSource.SetResult(null);
}
catch (Exception e)
{
taskSource.SetException(e);
}
});
await taskSource.Task;
}
