Track Editor/MariaTrackServiceEngine source
Jump to navigation
Jump to search
< Back to: Track_service_engine
public class MariaTrackServiceEngine
{
private ITrackServiceClient _trackServiceClient;
#region Connection
private void SetDisposed()
{
if (_trackServiceClient != null)
{
_trackServiceClient.Dispose();
}
}
private void HandleConnect()
{
_trackServiceClient.Connect();
// client is using async connection pattern. Must wait for connection.
// TODO: Find a better mechanism....
var cnt = 0;
while (!_trackServiceClient.Connected && cnt++ < 25) // Max 5 sec or give up....
{
Thread.Sleep(200);
}
Trace.WriteLine("TrackServiceClient connected on: " + cnt);
}
/// <summary>
/// Get current connection status.
/// </summary>
/// <returns>
/// True if connected, false if not.
/// </returns>
public bool IsConnected()
{
if (_trackServiceClient == null || !_trackServiceClient.Connected)
{
return false;
}
return true;
}
/// <summary>
/// Connect to specified track service
/// </summary>
/// <param name="uri">
/// Track service uri. If not supplied, configuration file definition is used.
/// </param>
/// <returns>
/// True if connected, false if not.
/// </returns>
public bool ConnectToTrackService(ref string uri)
{
string endpointConfigurationTrack = "TrackService";
IBindingFactory bindingFactory = new BindingFactory();
IEndpointAddressFactory endpointAddressFactory = new EndpointAddressFactory();
SetDisposed();
Binding binding = bindingFactory.NewFromConfigurationFile(endpointConfigurationTrack);
EndpointAddress endpoint;
if (!string.IsNullOrWhiteSpace(uri))
{
endpoint = endpointAddressFactory.New(uri);
}
else
{
endpoint = endpointAddressFactory.NewFromConfigurationFile(endpointConfigurationTrack);
}
_trackServiceClient = new TrackServiceClient(binding, endpoint);
HandleConnect();
if (!IsConnected())
return false;
uri = endpoint.Uri.AbsoluteUri;
return true;
}
/// <summary>
/// Disconnect from service.
/// </summary>
public void Disconnect()
{
SetDisposed();
_trackServiceClient = null;
}
#endregion Connection
#region TrackLists
/// <summary>
/// Retreive available tracklists matching the search criterias.
/// </summary>
/// <param name="useFilter"> </param>
/// <param name="filter">Filter value to use if useFilter is true.</param>
/// <returns>List of available track list ids.</returns>
public List<string> GetTrackLists(bool useFilter, string filter)
{
if (!IsConnected())
return null;
var res = _trackServiceClient.GetTrackListIds();
if (!useFilter || String.IsNullOrWhiteSpace(filter))
return new List<string>(res);
var filteredLists = new List<string>();
foreach (var tracklist in res)
{
if (tracklist.ToUpper().Contains(filter.ToUpper()))
filteredLists.Add(tracklist);
}
return filteredLists;
}
/// <summary>
/// Create a new track list
/// </summary>
/// <param name="newList">Track list id (name) of the list to be created.</param>
/// <returns>True if successfull, othervice false.</returns>
public bool AddTrackList(string newList)
{
if (!IsConnected())
return false;
_trackServiceClient.AddTrackList(newList);
return true;
}
/// <summary>
/// Remove track list, and all track info, if any.
/// </summary>
/// <param name="list">Id (name) of list to be removed.</param>
/// <returns>True if successfull, othervice false.</returns>
public bool RemoveTrackList(string list)
{
if (!IsConnected())
return false;
_trackServiceClient.RemoveTrackList(list);
return true;
}
#endregion TrackLists
#region Track History Options
/// <summary>
/// Set default track history options for new track lists.
/// </summary>
/// <param name="options">Track history options</param>
internal void SetDefaultTrackHistoryOptions(ITrackHistoryOptions options)
{
_trackServiceClient.SetDefaultTrackHistoryOptions(TrackHistOptionsToSettings(options));
}
/// <summary>
/// Set track history options for specified track list.
/// </summary>
/// <param name="trackList">Track list id</param>
/// <param name="options">Desired options.</param>
public void SetTrackHistoryOptions(string trackList, ITrackHistoryOptions options)
{
if (!string.IsNullOrWhiteSpace(trackList) /*&& options != null*/)
{
_trackServiceClient.SetTrackHistoryOptions(trackList, TrackHistOptionsToSettings(options));
}
}
/// <summary>
/// Retreive track history options for specified track list.
/// </summary>
/// <param name="tracklist"></param>
/// <returns></returns>
public ITrackHistoryOptions GetTrackHistoryOptions(string tracklist)
{
if (string.IsNullOrWhiteSpace(tracklist))
return null;
var tracksQuery = CreateTrackQuery(tracklist, new string[] { });
var historyQuery = CreateTrackHistoryQuery(new TrackHistoryFilterSpec(), tracksQuery);
var trackRawHistoryResult = _trackServiceClient.GetSpatialTrackHistory(tracklist, historyQuery);
if (trackRawHistoryResult == null || trackRawHistoryResult.HistorySettings == null)
{
return null;
}
return new TrackHistoryOptions
{
ChunkEntryCount = trackRawHistoryResult.HistorySettings.ChunkEntryCount,
PosResolutionCm = trackRawHistoryResult.HistorySettings.PosResolutionCm,
TimeResolutionMs = trackRawHistoryResult.HistorySettings.TimeResolutionMs
};
}
private static TrackHistorySettings TrackHistOptionsToSettings(ITrackHistoryOptions opt)
{
if (opt == null)
return null;
var set = new TrackHistorySettings();
if (opt.ChunkEntryCount.HasValue)
set.ChunkEntryCount = opt.ChunkEntryCount.Value;
if (opt.PosResolutionCm.HasValue)
set.PosResolutionCm = opt.PosResolutionCm.Value;
if (opt.TimeResolutionMs.HasValue)
set.TimeResolutionMs = opt.TimeResolutionMs.Value;
return set;
}
#endregion Track History Options
#region Tracks
/// <summary>
/// Retreive available tracks from a specific track list, matching the search criterias.
/// </summary>
/// <param name="tracklist">Track list id</param>
/// <param name="useIdFilter">True or false</param>
/// <param name="idFilter">
/// If useIdFilter is true and idFilter not empty, only tracks with track id matching the filter are returned.
/// </param>
/// <param name="useTagFilter">True or false</param>
/// <param name="tagFilterKey">
/// If useTagFilter is true and tagFilterKey not empty, only tracks with tag name matching the filter are returned.
/// </param>
/// <param name="tagFilterValue">
/// If useTagFilter is true and tagFilterKey and tagFilterValue not empty,
/// only tracks with tag name and value matching the filters are returned.
/// </param>
/// <returns>Array of tracks</returns>
public ITrackData[] GetAllTracks(
string tracklist,
bool useIdFilter,
string idFilter,
bool useTagFilter,
string tagFilterKey,
string tagFilterValue)
{
if (!IsConnected() || string.IsNullOrWhiteSpace(tracklist))
return null;
var trackServiceReader = new TrackServiceReader(new TrackServiceClientResources(_trackServiceClient));
var tracks = trackServiceReader.GetTracks(tracklist, DateTime.UtcNow);
if ((!useIdFilter || string.IsNullOrWhiteSpace(idFilter))
&& (!useTagFilter || string.IsNullOrWhiteSpace(tagFilterKey)))
return tracks.ToArray();
var returnValues = new List<ITrackData>();
foreach (var track in tracks)
{
if (useIdFilter)
{
if (track.TrackItemId.InstanceId.ToUpper().Contains(idFilter.ToUpper()))
{
if (!useTagFilter || string.IsNullOrWhiteSpace(tagFilterKey))
{
returnValues.Add(track);
}
else
{
foreach (var field in track.Fields)
{
if (field.Key.ToUpper().Contains(tagFilterKey.ToUpper()) &&
(string.IsNullOrWhiteSpace(tagFilterValue) ||
field.Value.ToUpper().Contains(tagFilterValue.ToUpper())))
{
returnValues.Add(track);
break;
}
}
}
}
}
else if (useTagFilter)
{
foreach (var field in track.Fields)
{
if (field.Key.ToUpper().Contains(tagFilterKey.ToUpper()) &&
(string.IsNullOrWhiteSpace(tagFilterValue) ||
field.Value.ToUpper().Contains(tagFilterValue.ToUpper())))
{
returnValues.Add(track);
break;
}
}
}
}
return returnValues.ToArray();
}
/// <summary>
/// Retreive specified tracks from a specific track list.
/// </summary>
/// <param name="tracklist">Track list id</param>
/// <param name="trackIds">List of track id of tracks to be retreived.</param>
/// <returns>Array of tracks</returns>
public ITrackData[] GetTrackData(string tracklist, params string[] trackIds)
{
if (!IsConnected())
return null;
ITrackServiceReader trackServiceReader = new TrackServiceReader(new TrackServiceClientResources(_trackServiceClient));
var tracks = trackServiceReader.GetTracks(tracklist, new List<string>(trackIds), DateTime.UtcNow).ToArray();
return tracks;
}
/// <summary>
/// Create or update specific track.
/// </summary>
/// <param name="tracklist">Track list id</param>
/// <param name="trackData">Track data.</param>
/// <returns></returns>
public bool AddOrUpdateTrack(string tracklist, ITrackData trackData)
{
if (!IsConnected())
return false;
ITrackServiceWriter trackServiceWriter = new TrackServiceWriter(new TrackServiceClientResources(_trackServiceClient));
trackServiceWriter.WriteTracks(tracklist, new[] { trackData }, DateTime.UtcNow);
return true;
}
/// <summary>
/// Remove specified track from specific track list
/// </summary>
/// <param name="tracklist">Track list id</param>
/// <param name="track">Track id</param>
/// <returns>True if successfull, othervice false.</returns>
public bool RemoveTrack(string tracklist, string track)
{
if (!IsConnected())
return false;
// _mariaTrackAccessAPI.DeleteTrackData(_trackServiceClient, tracklist, track) == MariaAPIResult.OperationSucceeded;
var fdefs = new TrackFieldDefinitions(tracklist);
var tracks = PackedDeleteMessages(fdefs, new[] { track });
var trackUpdates = new PackedTrackUpdates { CodedWith = fdefs.GetDefaultFieldDefinitionsQuery().Context };
trackUpdates.Messages.AddRange(tracks);
var processResult = _trackServiceClient.ProcessPackedTracks(tracklist, trackUpdates);
if (processResult == null || processResult.Deleted == 0)
{
return false;
}
return true;
}
#endregion Tracks
#region Track History
/// <summary>
/// Retreive available track history information for specified track & track list, according to filter criterias.
/// </summary>
/// <param name="list"></param>
/// <param name="historyFilterSpec"></param>
/// <param name="track"></param>
/// <returns></returns>
public List<ITrackHistoryData> GetTrackHistory(string list, ITrackHistoryFilterSpec historyFilterSpec, string track)
{
var tracksQuery = CreateTrackQuery(list, new[] { track });
ITrackServiceReader trackServiceReader = new TrackServiceReader(new TrackServiceClientResources(_trackServiceClient));
var history = trackServiceReader.GetTrackHistory(list, tracksQuery, historyFilterSpec, DateTime.UtcNow);
return history;
}
#endregion Track History
#region Local functions
private IEnumerable<PackedTrackMessage> PackedDeleteMessages(
ITrackFieldDefinitions fieldDefinitions, IEnumerable<string> trackIds)
{
var messages = new List<PackedTrackMessage>();
foreach (var trackId in trackIds)
{
var packedMessage = new PackedTrackMessage { MessageType = TrackMessageType.TrackMessageDelete };
TrackCodec.SetId(trackId, fieldDefinitions, packedMessage);
messages.Add(packedMessage);
}
return messages;
}
private static TrackHistoryQuery CreateTrackHistoryQuery(ITrackHistoryFilterSpec historyFilterSpec, TrackQuery tracksQuery)
{
var historyQuery = new TrackHistoryQuery();
var queryItem = new TrackHistoryQueryItem
{
Query = tracksQuery,
CurrentTimeRef = historyFilterSpec.CurrentTimeRef.ToFileTimeUtc()
};
if (historyFilterSpec.HistoryTimeLimit.HasValue)
queryItem.MaxAge = (uint)historyFilterSpec.HistoryTimeLimit.Value.TotalSeconds;
if (historyFilterSpec.HistoryElementLimit.HasValue)
queryItem.MaxHistoryPoints = historyFilterSpec.HistoryElementLimit.Value;
historyQuery.Queries.Add(queryItem);
return historyQuery;
}
private static TrackQuery CreateTrackAreaQuery(GeoRect searchArea)
{
var query = new TrackQuery();
var gq = new TrackGeoQuery { Area = new TrackAreaQuery() };
gq.Area.AreaPoly.Add(new Position { Lat = searchArea.LowerLeft.Lat, Lon = searchArea.LowerLeft.Lon });
gq.Area.AreaPoly.Add(new Position { Lat = searchArea.UpperRight.Lat, Lon = searchArea.UpperRight.Lon });
query.GeoQueries.Add(gq);
return query;
}
private static TrackQuery CreateTrackQuery(string trackListId, IEnumerable<string> trackIds)
{
var itemIds = new List<ItemId>();
foreach (var id in trackIds)
{
itemIds.Add(new ItemId(trackListId, id));
}
var query = TrackQueryGenerator.CreateMultiTracksQuery(itemIds);
return query;
}
#endregion Local functions
}