public static Map GetMap(MapsEntities entities, int mapId)
{
if (MapExists(mapId))
return StudMapCache.Global.Maps[mapId];
else
return new Map();
}
public void UpdateGraph(MapsEntities entities)
{
Nodes = GraphService.GetNodesDictionary(entities, Id);
Edges = GraphService.GetEdgeList(entities, Id);
GraphsForFloor = GraphService.GetAllGraphs(entities, Floors.Select(f => f.Id));
PathFinder = NavigationService.ComputeShortestPaths(Nodes, Edges);
}
public static Floor GetFloor(MapsEntities entities, int floorId)
{
Floors floor = entities.Floors.FirstOrDefault(x => x.Id == floorId);
if (floor == null)
throw new ServiceException(ResponseError.FloorIdDoesNotExist);
return Conversions.ToFloor(floor, ServerAdminBasePath);
}
public FingerprintCache()
{
TimeoutInMinutes = TIMEOUT;
using (var entities = new MapsEntities())
{
Update(entities);
}
}
public static Node GetNodeForQRCode(MapsEntities entities, int mapId, string qrCode)
{
Data.Entities.NodeInformation nodeInformation =
entities.NodeInformation.FirstOrDefault(x => x.QRCode == qrCode);
if (nodeInformation == null)
throw new ServiceException(ResponseError.QRCodeDosNotExist);
return Conversions.ToNode(nodeInformation.Nodes);
}
public static Node GetNodeForNFC(MapsEntities entities, int mapId, string nfcTag)
{
Data.Entities.NodeInformation nodeInformation =
entities.NodeInformation.FirstOrDefault(x => x.NFCTag == nfcTag);
if (nodeInformation == null)
throw new ServiceException(ResponseError.NFCTagDoesNotExist);
return Conversions.ToNode(nodeInformation.Nodes);
}
public GlobalCacheObject()
{
TimeoutInMinutes = 24 * 60;
using (var entities = new MapsEntities())
{
Update(entities);
}
}
public FingerprintCacheObject(int mapId)
{
TimeoutInMinutes = Timeout;
MapId = mapId;
using (var entities = new MapsEntities())
{
Update(entities);
}
}
public MapCache(int mapId)
{
TimeoutInMinutes = TIMEOUT;
ID = mapId;
using (var entities = new MapsEntities())
{
Update(entities);
}
}
public static void DeleteGraphForFloor(MapsEntities entities, int floorId)
{
Floors floor = entities.Floors.Find(floorId);
if (floor == null)
throw new ServiceException(ResponseError.FloorIdDoesNotExist);
int mapId = floor.MapId;
entities.DeleteGraphFromFloor(floorId);
StudMapCache.RemoveMap(mapId);
}
private static List<Edge> CreateEdgeListe(MapsEntities entities, int mapId)
{
var edges = from edge in entities.Edges
where edge.Graphs.MapId == mapId
select new Edge
{
StartNodeId = edge.NodeStartId,
EndNodeId = edge.NodeEndId
};
return edges.ToList();
}
public static Dictionary<int, Dictionary<int, Normal>> ComputeNodeDistribution(MapsEntities entities)
{
var nodeDistributions = new Dictionary<int, Dictionary<int, Normal>>();
foreach (RSSDistribution dist in entities.RSSDistribution)
{
if (!nodeDistributions.ContainsKey(dist.NodeId))
nodeDistributions.Add(dist.NodeId, new Dictionary<int, Normal>());
nodeDistributions[dist.NodeId].Add(dist.AccessPointId,
Normal.WithMeanStdDev(dist.AvgRSS ?? 0, dist.StDevRSS ?? 0.0));
}
return nodeDistributions;
}
public static FullNodeInformation GetFullNodeInformationForNode(MapsEntities entities, int nodeId)
{
NodeInformation info = GetNodeInformationForNode(entities, nodeId);
Floor floor = FloorService.GetFloor(entities, info.Node.FloorId);
Map map = MapService.GetMap(entities, floor.MapId);
return new FullNodeInformation
{
Map = map,
Floor = floor,
Info = info
};
}
private static Dictionary<int, Dictionary<int, Normal>> CalculateNodeDist(MapsEntities entities)
{
var nodeDistributions = new Dictionary<int, Dictionary<int, Normal>>();
foreach (var dist in entities.RSSDistribution)
{
if (!nodeDistributions.ContainsKey(dist.NodeId))
nodeDistributions.Add(dist.NodeId, new Dictionary<int, Normal>());
// Standardabweichung auf einen beliebigen Wert setzen, wenn
nodeDistributions[dist.NodeId].Add(dist.AccessPointId,
Normal.WithMeanStdDev(dist.AvgRSS ?? 0, dist.StDevRSS ?? 1.0));
}
return nodeDistributions;
}
public static Map CreateMap(MapsEntities entities, string mapName)
{
var newMap = new Maps
{
Name = mapName,
CreationTime = DateTime.Now
};
Maps insertedMap = entities.Maps.Add(newMap);
entities.SaveChanges();
StudMapCache.Global.UpdateMaps(entities);
return Conversions.ToMap(insertedMap);
}
public static List<NodeInformation> GetNodeInformation(MapsEntities entities, int mapId, int floorId)
{
if (!StudMapCache.Global.Maps.ContainsKey(mapId))
throw new ServiceException(ResponseError.MapIdDoesNotExist);
if (!entities.Floors.Any(f => f.Id == floorId))
throw new ServiceException(ResponseError.FloorIdDoesNotExist);
List<Data.Entities.NodeInformation> nodes = entities.NodeInformation
.Where(
n =>
n.Nodes.Floors.MapId == mapId &&
n.Nodes.FloorId == floorId)
.ToList();
return nodes.Select(Conversions.ToNodeInformation).ToList();
}
public static NodeInformation GetNodeInformationForNode(MapsEntities entities, int nodeId)
{
var result = new NodeInformation();
Nodes node = entities.Nodes.Find(nodeId);
if (node == null)
throw new ServiceException(ResponseError.NodeIdDoesNotExist);
result.Node = Conversions.ToNode(node);
Data.Entities.NodeInformation queriedNodeInformation =
entities.NodeInformation.FirstOrDefault(x => x.NodeId == nodeId);
// Wenn keine Infos hinterlegt sind, dann leere Info zurückgegeben
// Wichtig: Das ist kein Fehlerfall
if (queriedNodeInformation == null)
return result;
return Conversions.ToNodeInformation(queriedNodeInformation);
}
public static void SaveFingerprintForNode(MapsEntities entities, int nodeId, Fingerprint fingerprint)
{
if (fingerprint == null)
throw new ServiceException(ResponseError.FingeprintIsNotDefined);
if (fingerprint.AccessPointScans == null || !fingerprint.AccessPointScans.Any())
return;
Nodes node = entities.Nodes.Find(nodeId);
if (node == null)
throw new ServiceException(ResponseError.NodeIdDoesNotExist);
// Fingerprint in DB einfügen
Fingerprints fingerprints = entities.Fingerprints.Add(new Fingerprints
{
NodeId = node.Id
});
entities.SaveChanges();
foreach (AccessPointScan apScan in fingerprint.AccessPointScans)
{
// Fehlenden AccessPoint ggf. anlegen
AccessPoints ap = entities.AccessPoints.FirstOrDefault(x => x.MAC == apScan.AccessPoint.MAC);
if (ap == null)
{
ap = entities.AccessPoints.Add(new AccessPoints
{
MAC = apScan.AccessPoint.MAC
});
entities.SaveChanges();
}
// Einzelmessung speichern
entities.AccessPointScans.Add(new AccessPointScans
{
AccessPointId = ap.Id,
RecievedSignalStrength = apScan.ReceivedSignalStrength,
FingerprintId = fingerprints.Id
});
}
entities.SaveChanges();
StudMapCache.RemoveFingerprint(node.Floors.MapId);
}
public static Floor CreateFloor(MapsEntities entities, int mapId, string name, string imageUrl)
{
if (!MapService.MapExists(mapId))
throw new ServiceException(ResponseError.MapIdDoesNotExist);
var newFloor = new Floors
{
MapId = mapId,
Name = name,
ImageUrl = imageUrl,
CreationTime = DateTime.Now
};
Floors insertedFloor = entities.Floors.Add(newFloor);
entities.SaveChanges();
StudMapCache.RemoveMap(mapId);
return Conversions.ToFloor(insertedFloor, ServerAdminBasePath);
}
public static Graph GetGraphForFloor(MapsEntities entities, int floorId)
{
Floors queriedFloor = entities.Floors.Find(floorId);
if (queriedFloor == null)
throw new ServiceException(ResponseError.FloorIdDoesNotExist);
// Array aus Node-IDs auf dem angeforderten Floor erstellen
ICollection<Nodes> nodes = queriedFloor.Nodes;
IEnumerable<int> nodeIds = nodes.Select(n => n.Id);
int[] nodeIdArray = nodeIds as int[] ?? nodeIds.ToArray();
// TODO: Hier wirklich auch Kanten zurückgeben, von denen nur
// ein Endknoten auf dem geforderten Floor ist?
// Erstmal nur Kanten, die komplett auf dem Floor sind zurückgeben
IQueryable<Edges> edges = entities.Edges.Where(e =>
nodeIdArray.Contains(e.NodeStartId) &&
nodeIdArray.Contains(e.NodeEndId));
return Conversions.ToGraph(floorId, nodes, edges);
}
public static List<NodeProbability> GetNodeProbabiltyForScan(MapsEntities entities, LocationRequest request)
{
// Gesammelte WLAN-Fingerprints aus DB auswerten und Verteilung bestimmen
// Jetzt: gecachet!
FingerprintCacheObject cache = StudMapCache.Fingerprint(request.MapId);
MapCacheObject mapCache = StudMapCache.Map(request.MapId);
Node previousNode = mapCache.Nodes.ContainsKey(request.PreviousNodeId)
? mapCache.Nodes[request.PreviousNodeId]
: new Node {Id = 0};
// AccessPoint-Messung nach APs aufteilen
Dictionary<int, int> apScans = AnalyseInputScan(request.Scans, cache.MACtoAP);
// W'keit bestimmen, dass RSS-Werte an Knoten gemessen werden
Func<int, double> getDistance;
if (request.PreviousNodeId == 0)
getDistance = nodeId => 1.0;
else
getDistance = nodeId =>
{
double distance;
if (mapCache.PathFinder.TryGetDistance(previousNode.Id, nodeId, out distance))
return distance;
else
return -1;
};
List<NodeProbability> nodeProbs = CalculateNodeProbabilities(cache.NodeDistributions, apScans, getDistance);
// Absteigend nach W'keit sortieren
nodeProbs.Sort((m, n) => n.Probabilty.CompareTo(m.Probabilty));
// Maximal die angeforderte Anzahl an Knoten zurückliefern
int count = Math.Min(request.NodeCount, nodeProbs.Count);
return nodeProbs.GetRange(0, count);
}
public static List<Node> GetConnectedNodes(MapsEntities entities, int nodeId)
{
bool nodeExists = entities.Nodes.Any(n => n.Id == nodeId);
if (!nodeExists)
throw new ServiceException(ResponseError.NodeIdDoesNotExist);
// Node-IDs aller Endknoten der verbundenen Kanten sammeln
IQueryable<Edges> edges = entities.Edges.Where(
e => e.NodeStartId == nodeId || e.NodeEndId == nodeId);
var connectedNodeIds = new HashSet<int>();
foreach (Edges edge in edges)
{
connectedNodeIds.Add(edge.NodeStartId);
connectedNodeIds.Add(edge.NodeEndId);
}
// Den angeforderten Knoten herausfiltern
connectedNodeIds.Remove(nodeId);
IQueryable<Nodes> connectedNodes = entities.Nodes.Where(
n => connectedNodeIds.Contains(n.Id));
return connectedNodes.ToList()
.Select(Conversions.ToNode).ToList();
}
public void Update(MapsEntities entities)
{
MACtoAP = FingerprintService.CreateMACtoAPLookup(entities);
NodeDistributions = FingerprintService.ComputeNodeDistribution(entities);
}
private static Dictionary<string, int> CreateMACtoAPLookup(MapsEntities entities)
{
return entities.AccessPoints.ToDictionary(ap => ap.MAC, ap => ap.Id);
}
public void Update(MapsEntities entities)
{
NodeDistributions = CalculateNodeDist(entities);
MACtoAP = CreateMACtoAPLookup(entities);
}
public static List<Edge> GetEdgeList(MapsEntities entities, int mapId)
{
return entities.Edges.Where(e => e.Graphs.MapId == mapId).ToList()
.Select(Conversions.ToEdge).ToList();
}
private void Update(MapsEntities entities)
{
UpdateMaps(entities);
UpdateFloors(entities);
}
public void UpdateMaps(MapsEntities entities)
{
Maps = MapService.GetMaps(entities);
}
public void UpdateFloors(MapsEntities entities)
{
Floors = FloorService.GetAllFloors(entities);
}
public static Dictionary<int, Node> GetNodesDictionary(MapsEntities entities, int mapId)
{
return entities.Nodes.Where(n => n.Floors.MapId == mapId).ToList()
.Select(Conversions.ToNode).ToDictionary(n => n.Id);
}
