// GET /service/ID?accessToken=[your token]
public async Task <ServiceDetails> Get([FromUri] ServiceRequest request)
{
Guid sid;
if (Guid.TryParse(request.ServiceId, out sid))
{
request.ServiceId = Convert.ToBase64String(sid.ToByteArray());
}
var client = new LDBServiceSoapClient();
// Avoiding Problems with the Using Statement in WCF clients
// https://msdn.microsoft.com/en-us/library/aa355056.aspx
try {
var token = MakeAccessToken(request.AccessToken);
var service = await client.GetServiceDetailsAsync(token, request.ServiceId);
return(service.GetServiceDetailsResult);
} catch (CommunicationException) {
client.Abort();
} catch (TimeoutException) {
client.Abort();
} catch (Exception) {
client.Abort();
throw;
} finally {
client.Close();
}
return(new ServiceDetails());
}
// GET /{board}/CRS?accessToken=[your token]
public async Task <StationBoard> Get([FromUri] StationBoardRequest request)
{
// Process CRS codes
request.Crs = MakeCrsCode(request.Crs);
request.FilterCrs = MakeCrsCode(request.FilterCrs);
var client = new LDBServiceSoapClient();
// Avoiding Problems with the Using Statement in WCF clients
// https://msdn.microsoft.com/en-us/library/aa355056.aspx
try {
var token = MakeAccessToken(request.AccessToken);
if (Board.Departures == request.Board)
{
var departures = await client.GetDepartureBoardAsync(token, request.NumRows, request.Crs, request.FilterCrs, request.FilterType, 0, 0);
return(departures.GetStationBoardResult);
}
if (Board.Arrivals == request.Board)
{
var arrivals = await client.GetArrivalBoardAsync(token, request.NumRows, request.Crs, request.FilterCrs, request.FilterType, 0, 0);
return(arrivals.GetStationBoardResult);
}
// Default all (departures and arrivals board)
var board = await client.GetArrivalDepartureBoardAsync(token, request.NumRows, request.Crs, request.FilterCrs, request.FilterType, 0, 0);
return(board.GetStationBoardResult);
} catch (CommunicationException) {
client.Abort();
} catch (TimeoutException) {
client.Abort();
} catch (Exception) {
client.Abort();
throw;
} finally {
client.Close();
}
return(new StationBoard());
}
private T Execute <T>(Func <T> func)
{
// Avoiding Problems with the Using Statement in WCF clients
try {
return(func());
} catch (Exception) {
client.Abort();
throw;
} finally {
client.Close();
}
}
// GET /delays/{crs}/{filtertype}/{filtercrs}/{numrows}/{stds}?accessToken=[your token]
public async Task <DelaysResponse> Get([FromUri] StationBoardRequest request)
{
// Process CRS codes
request.Crs = MakeCrsCode(request.Crs);
request.FilterCrs = MakeCrsCode(request.FilterCrs);
// Parse the list of comma separated STDs if provided (e.g. /btn/to/lon/50/0729,0744,0748)
var stds = new List <string>();
if (!string.IsNullOrWhiteSpace(request.Std))
{
var potentialStds = request.Std.Split(',');
var ukNow = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, TimeZoneInfo.FindSystemTimeZoneById("GMT Standard Time"));
var dontRequest = 0;
foreach (var potentialStd in potentialStds)
{
DateTime requestStd;
// Parse the STD in 24-hour format (with no colon)
if (!DateTime.TryParseExact(potentialStd, "HHmm", CultureInfo.InvariantCulture, DateTimeStyles.None, out requestStd))
{
continue;
}
stds.Add(potentialStd);
var diff = requestStd.Subtract(ukNow);
if (diff.TotalHours > 2 || diff.TotalHours < -1)
{
dontRequest++;
}
}
// Don't make a request if all trains are more than 2 hours in the future or more than 1 hour in the past
if (stds.Count > 0 && stds.Count == dontRequest)
{
return(new DelaysResponse());
}
}
var londonTerminals = new List <string> {
"BFR", "LBG", "CST", "CHX", "EUS", "FST", "KGX", "LST", "MYB", "PAD", "STP", "SPX", "VIC", "WAT", "WAE",
};
var client = new LDBServiceSoapClient();
// Avoiding Problems with the Using Statement in WCF clients
// https://msdn.microsoft.com/en-us/library/aa355056.aspx
try {
var totalDelayMinutes = 0;
var delayedTrains = new List <ServiceItem>();
var token = MakeAccessToken(request.AccessToken);
var filterCrs = request.FilterCrs;
if (request.FilterCrs.Equals("LON", StringComparison.InvariantCultureIgnoreCase) ||
request.FilterCrs.Equals("London", StringComparison.InvariantCultureIgnoreCase))
{
filterCrs = null;
}
var board = await client.GetDepartureBoardAsync(token, request.NumRows, request.Crs, filterCrs, request.FilterType, 0, 0);
var response = board.GetStationBoardResult;
var filterLocationName = response.filterLocationName;
var trainServices = response.trainServices ?? new ServiceItem[0];
var railReplacement = null != response.busServices && !trainServices.Any() && response.busServices.Any();
var messagesPresent = null != response.nrccMessages && response.nrccMessages.Any();
if (null == filterCrs)
{
// This only finds trains terminating at London terminals. BFR/STP etc. won't be picked up if called at en-route.
// Could query for every terminal or get service for every train and check calling points. Very chatty either way.
switch (request.FilterType)
{
case FilterType.to:
trainServices = trainServices.Where(ts => ts.destination.Any(d => londonTerminals.Contains(d.crs.ToUpperInvariant()))).ToArray();
break;
case FilterType.from:
trainServices = trainServices.Where(ts => ts.origin.Any(d => londonTerminals.Contains(d.crs.ToUpperInvariant()))).ToArray();
break;
default:
throw new ArgumentOutOfRangeException();
}
filterCrs = "LON";
filterLocationName = "London";
}
// If STDs are provided then select only the train(s) matching them
if (stds.Count > 0)
{
trainServices = trainServices.Where(ts => stds.Contains(ts.std.Replace(":", ""))).ToArray();
}
// Parse the response from the web service.
foreach (var si in trainServices.Where(si => !si.etd.Equals("On time", StringComparison.InvariantCultureIgnoreCase)))
{
if (si.etd.Equals("Delayed", StringComparison.InvariantCultureIgnoreCase) ||
si.etd.Equals("Cancelled", StringComparison.InvariantCultureIgnoreCase))
{
delayedTrains.Add(si);
}
else
{
DateTime etd;
// Could be "Starts Here", "No Report" or contain a * (report overdue)
if (DateTime.TryParse(si.etd.Replace("*", ""), out etd))
{
DateTime std;
if (DateTime.TryParse(si.std, out std))
{
var late = etd.Subtract(std);
totalDelayMinutes += (int)late.TotalMinutes;
if (late.TotalMinutes > HuxleyApi.Settings.DelayMinutesThreshold)
{
delayedTrains.Add(si);
}
}
}
}
}
return(new DelaysResponse {
GeneratedAt = response.generatedAt,
Crs = response.crs,
LocationName = response.locationName,
Filtercrs = filterCrs,
FilterLocationName = filterLocationName,
Delays = delayedTrains.Count > 0 || railReplacement || messagesPresent,
TotalTrainsDelayed = delayedTrains.Count,
TotalDelayMinutes = totalDelayMinutes,
TotalTrains = trainServices.Length,
DelayedTrains = delayedTrains,
});
} catch (CommunicationException) {
client.Abort();
} catch (TimeoutException) {
client.Abort();
} catch (Exception) {
client.Abort();
throw;
} finally {
client.Close();
}
return(new DelaysResponse());
}
