/// <summary>
/// Builds a select statement from criteria.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
/// <param name="justCount"></param>
/// <returns></returns>
private string CreateSelectFrom(BaseStationAircraft aircraft, SearchBaseStationCriteria criteria, bool justCount)
{
StringBuilder result = new StringBuilder();
if (aircraft != null)
{
result.AppendFormat("SELECT {0} FROM [Flights] AS f", justCount ? "COUNT(*)" : FieldList());
}
else
{
result.AppendFormat("SELECT {0}{1}{2} FROM ",
justCount ? "COUNT(*)" : FieldList(),
justCount ? "" : ", ",
justCount ? "" : AircraftTable.FieldList());
if (FilterByAircraftFirst(criteria))
{
result.Append("[Aircraft] AS a LEFT JOIN [Flights] AS f");
}
else
{
result.Append("[Flights] AS f LEFT JOIN [Aircraft] AS a");
}
result.Append(" ON (a.[AircraftID] = f.[AircraftID])");
}
return(result.ToString());
}
public void AircraftDetailFetcher_BaseStationDatabase_FileNameChanged_Forces_Refresh_Of_All_Database_Details_On_Next_Fast_Tick()
{
// If it performed the refetch immediately then it could cause the options screen to appear to hang as the event
// is probably being raised on the GUI thread. Pushing it to the next fast heartbeat stops that, it'll happen on
// our timer thread.
_DatabaseAircraftAndFlights = new BaseStationAircraftAndFlightsCount()
{
ModeS = "ABC123", Registration = "OLD"
};
_Fetcher.RegisterAircraft(_Aircraft.Object);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
_DatabaseAircraft = new BaseStationAircraft()
{
ModeS = "ABC123", Registration = "NEW"
};
_Database.Raise(r => r.FileNameChanged += null, EventArgs.Empty);
Assert.AreEqual(1, _FetchedHandler.CallCount);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
Assert.AreEqual(2, _FetchedHandler.CallCount);
var lastArgs = _FetchedHandler.AllArgs[1].Value;
Assert.AreSame(_DatabaseAircraft, lastArgs.Aircraft);
}
/// <summary>
/// Returns the WHERE portion of an SQL statement contains the fields describing the criteria passed across.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
/// <returns></returns>
public static CriteriaAndProperties GetFlightsCriteria(BaseStationAircraft aircraft, SearchBaseStationCriteria criteria)
{
var result = new CriteriaAndProperties();
StringBuilder command = new StringBuilder();
if (aircraft != null)
{
DynamicSqlBuilder.AddWhereClause(command, "[Flights].[AircraftID]", " = @aircraftID");
result.Parameters.Add("aircraftID", aircraft.AircraftID);
}
if (criteria.UseAlternateCallsigns && criteria.Callsign != null && criteria.Callsign.Condition == FilterCondition.Equals && !String.IsNullOrEmpty(criteria.Callsign.Value))
{
GetAlternateCallsignCriteria(command, result.Parameters, criteria.Callsign, "[Flights].[Callsign]");
}
else
{
DynamicSqlBuilder.AddCriteria(command, criteria.Callsign, result.Parameters, "[Flights].[Callsign]", "callsign");
}
DynamicSqlBuilder.AddCriteria(command, criteria.Date, result.Parameters, "[Flights].[StartTime]", "fromStartTime", "toStartTime");
DynamicSqlBuilder.AddCriteria(command, criteria.Operator, result.Parameters, "[Aircraft].[RegisteredOwners]", "registeredOwners");
DynamicSqlBuilder.AddCriteria(command, criteria.Registration, result.Parameters, "[Aircraft].[Registration]", "registration");
DynamicSqlBuilder.AddCriteria(command, criteria.Icao, result.Parameters, "[Aircraft].[ModeS]", "icao");
DynamicSqlBuilder.AddCriteria(command, criteria.Country, result.Parameters, "[Aircraft].[ModeSCountry]", "modeSCountry");
DynamicSqlBuilder.AddCriteria(command, criteria.IsEmergency, "[Flights].[HadEmergency]");
DynamicSqlBuilder.AddCriteria(command, criteria.Type, result.Parameters, "[Aircraft].[ICAOTypeCode]", "modelIcao");
DynamicSqlBuilder.AddCriteria(command, criteria.FirstAltitude, result.Parameters, "[Flights].[FirstAltitude]", "fromFirstAltitude", "toFirstAltitude");
DynamicSqlBuilder.AddCriteria(command, criteria.LastAltitude, result.Parameters, "[Flights].[LastAltitude]", "fromLastAltitude", "toLastAltitude");
result.SqlChunk = command.ToString();
return(result);
}
/// <summary>
/// Attaches ADO.NET parameters to the command passed across to carry the criteria values to the database engine.
/// </summary>
/// <param name="command"></param>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
private void AddFlightsCriteriaParameters(IDbCommand command, BaseStationAircraft aircraft, SearchBaseStationCriteria criteria)
{
if (aircraft != null)
{
Sql.AddParameter(command, aircraft.AircraftID);
}
if (!String.IsNullOrEmpty(criteria.Callsign))
{
Sql.AddParameter(command, criteria.Callsign);
}
if (criteria.FromDate.Year != DateTime.MinValue.Year)
{
Sql.AddParameter(command, criteria.FromDate);
}
if (criteria.ToDate.Year != DateTime.MaxValue.Year)
{
Sql.AddParameter(command, criteria.ToDate);
}
if (!String.IsNullOrEmpty(criteria.Operator))
{
Sql.AddParameter(command, criteria.Operator);
}
if (!String.IsNullOrEmpty(criteria.Registration))
{
Sql.AddParameter(command, criteria.Registration);
}
if (!String.IsNullOrEmpty(criteria.Icao))
{
Sql.AddParameter(command, criteria.Icao);
}
if (!String.IsNullOrEmpty(criteria.Country))
{
Sql.AddParameter(command, criteria.Country);
}
}
/// <summary>
/// Builds a Dapper parameters object for an aircraft.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="includeAircraftID"></param>
/// <returns></returns>
public static DynamicParameters FromAircraft(BaseStationAircraft aircraft, bool includeAircraftID = true)
{
var result = new DynamicParameters();
if (includeAircraftID)
{
result.Add(nameof(aircraft.AircraftID), value: aircraft.AircraftID);
}
result.Add(nameof(aircraft.AircraftClass), value: aircraft.AircraftClass);
result.Add(nameof(aircraft.CofACategory), value: aircraft.CofACategory);
result.Add(nameof(aircraft.CofAExpiry), value: aircraft.CofAExpiry);
result.Add(nameof(aircraft.Country), value: aircraft.Country);
result.Add(nameof(aircraft.CurrentRegDate), value: aircraft.CurrentRegDate);
result.Add(nameof(aircraft.DeRegDate), value: aircraft.DeRegDate);
result.Add(nameof(aircraft.Engines), value: aircraft.Engines);
result.Add(nameof(aircraft.FirstCreated), value: aircraft.FirstCreated);
result.Add(nameof(aircraft.FirstRegDate), value: aircraft.FirstRegDate);
result.Add(nameof(aircraft.GenericName), value: aircraft.GenericName);
result.Add(nameof(aircraft.ICAOTypeCode), value: aircraft.ICAOTypeCode);
result.Add(nameof(aircraft.InfoUrl), value: aircraft.InfoUrl);
result.Add(nameof(aircraft.Interested), value: aircraft.Interested);
result.Add(nameof(aircraft.LastModified), value: aircraft.LastModified);
result.Add(nameof(aircraft.Manufacturer), value: aircraft.Manufacturer);
result.Add(nameof(aircraft.ModeS), value: aircraft.ModeS);
result.Add(nameof(aircraft.ModeSCountry), value: aircraft.ModeSCountry);
result.Add(nameof(aircraft.MTOW), value: aircraft.MTOW);
result.Add(nameof(aircraft.OperatorFlagCode), value: aircraft.OperatorFlagCode);
result.Add(nameof(aircraft.OwnershipStatus), value: aircraft.OwnershipStatus);
result.Add(nameof(aircraft.PictureUrl1), value: aircraft.PictureUrl1);
result.Add(nameof(aircraft.PictureUrl2), value: aircraft.PictureUrl2);
result.Add(nameof(aircraft.PictureUrl3), value: aircraft.PictureUrl3);
result.Add(nameof(aircraft.PopularName), value: aircraft.PopularName);
result.Add(nameof(aircraft.PreviousID), value: aircraft.PreviousID);
result.Add(nameof(aircraft.Registration), value: aircraft.Registration);
result.Add(nameof(aircraft.RegisteredOwners), value: aircraft.RegisteredOwners);
result.Add(nameof(aircraft.SerialNo), value: aircraft.SerialNo);
result.Add(nameof(aircraft.Status), value: aircraft.Status);
result.Add(nameof(aircraft.TotalHours), value: aircraft.TotalHours);
result.Add(nameof(aircraft.Type), value: aircraft.Type);
result.Add(nameof(aircraft.UserNotes), value: aircraft.UserNotes);
result.Add(nameof(aircraft.UserTag), value: aircraft.UserTag);
result.Add(nameof(aircraft.YearBuilt), value: aircraft.YearBuilt);
result.Add(nameof(aircraft.UserString1), value: aircraft.UserString1);
result.Add(nameof(aircraft.UserString2), value: aircraft.UserString2);
result.Add(nameof(aircraft.UserString3), value: aircraft.UserString3);
result.Add(nameof(aircraft.UserString4), value: aircraft.UserString4);
result.Add(nameof(aircraft.UserString5), value: aircraft.UserString5);
result.Add(nameof(aircraft.UserBool1), value: aircraft.UserBool1);
result.Add(nameof(aircraft.UserBool2), value: aircraft.UserBool2);
result.Add(nameof(aircraft.UserBool3), value: aircraft.UserBool3);
result.Add(nameof(aircraft.UserBool4), value: aircraft.UserBool4);
result.Add(nameof(aircraft.UserBool5), value: aircraft.UserBool5);
result.Add(nameof(aircraft.UserInt1), value: aircraft.UserInt1);
result.Add(nameof(aircraft.UserInt2), value: aircraft.UserInt2);
result.Add(nameof(aircraft.UserInt3), value: aircraft.UserInt3);
result.Add(nameof(aircraft.UserInt4), value: aircraft.UserInt4);
result.Add(nameof(aircraft.UserInt5), value: aircraft.UserInt5);
return(result);
}
/// <summary>
/// Creates the JSON representation of an aircraft.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="args"></param>
/// <returns></returns>
private ReportAircraftJson CreateReportAircraftJson(BaseStationAircraft aircraft, RequestReceivedEventArgs args)
{
var result = new ReportAircraftJson()
{
AircraftClass = aircraft.AircraftClass,
AircraftId = aircraft.AircraftID,
CofACategory = aircraft.CofACategory,
CofAExpiry = aircraft.CofAExpiry,
Country = aircraft.Country,
CurrentRegDate = aircraft.CurrentRegDate,
DeRegDate = aircraft.DeRegDate,
FirstRegDate = aircraft.FirstRegDate,
GenericName = aircraft.GenericName,
IcaoTypeCode = aircraft.ICAOTypeCode,
InfoUrl = aircraft.InfoUrl,
Manufacturer = aircraft.Manufacturer,
Icao = aircraft.ModeS,
ModeSCountry = aircraft.ModeSCountry,
MTOW = aircraft.MTOW,
OperatorFlagCode = aircraft.OperatorFlagCode,
OwnershipStatus = aircraft.OwnershipStatus,
PictureUrl1 = aircraft.PictureUrl1,
PictureUrl2 = aircraft.PictureUrl2,
PictureUrl3 = aircraft.PictureUrl3,
PopularName = aircraft.PopularName,
PreviousId = aircraft.PreviousID,
Registration = aircraft.Registration,
RegisteredOwners = aircraft.RegisteredOwners,
SerialNumber = aircraft.SerialNo,
Status = aircraft.Status,
TotalHours = aircraft.TotalHours,
Type = aircraft.Type,
Notes = aircraft.UserNotes,
YearBuilt = aircraft.YearBuilt,
HasPicture = args.IsInternetRequest && !_InternetClientCanSeePictures ? false : _PictureManager.FindPicture(_PictureFolderCache, aircraft.ModeS, aircraft.Registration) != null,
};
var aircraftType = String.IsNullOrEmpty(aircraft.ICAOTypeCode) ? null : StandingDataManager.FindAircraftType(aircraft.ICAOTypeCode);
if (aircraftType != null)
{
result.WakeTurbulenceCategory = (int)aircraftType.WakeTurbulenceCategory;
result.Engines = aircraftType.Engines;
result.EngineType = (int)aircraftType.EngineType;
result.Species = (int)aircraftType.Species;
}
var codeBlock = String.IsNullOrEmpty(aircraft.ModeS) ? null : StandingDataManager.FindCodeBlock(aircraft.ModeS);
if (codeBlock != null)
{
result.Military = codeBlock.IsMilitary;
}
return(result);
}
public void AircraftOnlineLookupManager_Lookup_Passes_Through_BaseStationAircraft_To_Cache()
{
var aircraft = new BaseStationAircraft();
_Manager.Lookup("ABC123", aircraft, true);
_Manager.Lookup("XYZ987", aircraft, false);
_Cache2.Verify(r => r.Load("ABC123", aircraft, true), Times.Once());
_Cache2.Verify(r => r.Load("XYZ987", aircraft, false), Times.Once());
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="icao"></param>
/// <param name="baseStationAircraft">Unused.</param>
/// <param name="searchedForBaseStationAircraft">Unused.</param>
/// <returns></returns>
public AircraftOnlineLookupDetail Load(string icao, BaseStationAircraft baseStationAircraft, bool searchedForBaseStationAircraft)
{
lock (_SyncLock) {
using (var connection = CreateOpenConnection()) {
return(connection.Query <AircraftOnlineLookupDetail>("SELECT * FROM [AircraftDetail] WHERE [Icao] = @icao", new {
icao = icao,
}).FirstOrDefault());
}
}
}
public void BaseStationAircraft_Initialises_To_Known_State_And_Properties_Work()
{
var baseStationAircraft = new BaseStationAircraft();
TestUtilities.TestProperty(baseStationAircraft, r => r.AircraftClass, null, "Ab");
TestUtilities.TestProperty(baseStationAircraft, r => r.AircraftID, 0, 129);
TestUtilities.TestProperty(baseStationAircraft, r => r.CofACategory, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.CofAExpiry, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.Country, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.CurrentRegDate, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.DeRegDate, null, "Nn");
TestUtilities.TestProperty(baseStationAircraft, r => r.Engines, null, "Xx");
TestUtilities.TestProperty(baseStationAircraft, r => r.FirstCreated, DateTime.MinValue, DateTime.Today);
TestUtilities.TestProperty(baseStationAircraft, r => r.FirstRegDate, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.GenericName, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.ICAOTypeCode, null, "Uu");
TestUtilities.TestProperty(baseStationAircraft, r => r.InfoUrl, null, "Uu");
TestUtilities.TestProperty(baseStationAircraft, r => r.Interested, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.LastModified, DateTime.MinValue, DateTime.Today);
TestUtilities.TestProperty(baseStationAircraft, r => r.Manufacturer, null, "Pp");
TestUtilities.TestProperty(baseStationAircraft, r => r.ModeS, null, "Ii");
TestUtilities.TestProperty(baseStationAircraft, r => r.ModeSCountry, null, "Ll");
TestUtilities.TestProperty(baseStationAircraft, r => r.MTOW, null, "Bb");
TestUtilities.TestProperty(baseStationAircraft, r => r.OperatorFlagCode, null, "Wx");
TestUtilities.TestProperty(baseStationAircraft, r => r.OwnershipStatus, null, "Ww");
TestUtilities.TestProperty(baseStationAircraft, r => r.PictureUrl1, null, "Uu");
TestUtilities.TestProperty(baseStationAircraft, r => r.PictureUrl2, null, "Uu");
TestUtilities.TestProperty(baseStationAircraft, r => r.PictureUrl3, null, "Uu");
TestUtilities.TestProperty(baseStationAircraft, r => r.PopularName, null, "Hg");
TestUtilities.TestProperty(baseStationAircraft, r => r.PreviousID, null, "Ds");
TestUtilities.TestProperty(baseStationAircraft, r => r.RegisteredOwners, null, "xZ");
TestUtilities.TestProperty(baseStationAircraft, r => r.Registration, null, "Vv");
TestUtilities.TestProperty(baseStationAircraft, r => r.SerialNo, null, "EWe");
TestUtilities.TestProperty(baseStationAircraft, r => r.Status, null, "St");
TestUtilities.TestProperty(baseStationAircraft, r => r.TotalHours, null, "Jjk");
TestUtilities.TestProperty(baseStationAircraft, r => r.Type, null, "Jjk");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserNotes, null, "Jjk");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserString1, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserString2, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserString3, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserString4, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserString5, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.UserBool1, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserBool2, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserBool3, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserBool4, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserBool5, false);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserInt1, 0L, 1L);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserInt2, 0L, 1L);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserInt3, 0L, 1L);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserInt4, 0L, 1L);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserInt5, 0L, 1L);
TestUtilities.TestProperty(baseStationAircraft, r => r.UserTag, null, "Abc");
TestUtilities.TestProperty(baseStationAircraft, r => r.YearBuilt, null, "Jjk");
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="icao"></param>
/// <param name="baseStationAircraft"></param>
/// <param name="searchedForBaseStationAircraft"></param>
/// <returns></returns>
public AircraftOnlineLookupDetail Lookup(string icao, BaseStationAircraft baseStationAircraft, bool searchedForBaseStationAircraft)
{
Initialise();
var result = FetchAircraftDetailsFromCache(icao, baseStationAircraft, searchedForBaseStationAircraft);
if (RecordNeedsRefresh(result))
{
_AircraftOnlineLookup.Lookup(icao);
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="registration"></param>
/// <returns></returns>
public BaseStationAircraft GetAircraftByRegistration(string registration)
{
BaseStationAircraft result = null;
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
result = _AircraftTable.GetByRegistration(_Connection, _TransactionHelper.Transaction, _DatabaseLog, registration);
}
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="icao24"></param>
/// <returns></returns>
public BaseStationAircraft GetAircraftByCode(string icao24)
{
BaseStationAircraft result = null;
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
result = _AircraftTable.GetByIcao(_Connection, _TransactionHelper.Transaction, _DatabaseLog, icao24);
}
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public BaseStationAircraft GetAircraftById(int id)
{
BaseStationAircraft result = null;
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
result = _AircraftTable.GetById(_Connection, _TransactionHelper.Transaction, _DatabaseLog, id);
}
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraft"></param>
public void DeleteAircraft(BaseStationAircraft aircraft)
{
if (!WriteSupportEnabled)
{
throw new InvalidOperationException("You cannot delete aircraft when write support is disabled");
}
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
_AircraftTable.Delete(_Connection, _TransactionHelper.Transaction, _DatabaseLog, aircraft);
}
}
}
private bool IsEmptyButNotMissing(BaseStationAircraft baseStationAircraft)
{
var result = baseStationAircraft == null;
if (!result)
{
result = String.IsNullOrEmpty(baseStationAircraft.Registration) &&
String.IsNullOrEmpty(baseStationAircraft.Manufacturer) &&
String.IsNullOrEmpty(baseStationAircraft.Type) &&
String.IsNullOrEmpty(baseStationAircraft.OperatorFlagCode) &&
baseStationAircraft.UserString1 != "Missing";
}
return(result);
}
/// <summary>
/// Fetches many aircraft simultaneously.
/// </summary>
/// <param name="fetchedDetails"></param>
/// <returns></returns>
protected override bool DoFetchManyAircraft(IEnumerable <AircraftFetcher <string, AircraftDetail> .FetchedDetail> fetchedDetails)
{
var allIcaos = fetchedDetails.Select(r => r.Key).ToArray();
var newIcaos = fetchedDetails.Where(r => r.Detail == null || r.Detail.Aircraft == null).Select(r => r.Key).ToArray();
var existingIcaos = fetchedDetails.Where(r => r.Detail != null && r.Detail.Aircraft != null).Select(r => r.Key).ToArray();
var aircraftAndFlightCounts = _AutoConfigDatabase.Database.GetManyAircraftAndFlightsCountByCode(newIcaos);
var aircraft = _AutoConfigDatabase.Database.GetManyAircraftByCode(existingIcaos);
var combinedAircraft = new Dictionary <string, BaseStationAircraft>();
foreach (var kvp in aircraftAndFlightCounts)
{
combinedAircraft.Add(kvp.Key, kvp.Value);
}
foreach (var kvp in aircraft)
{
combinedAircraft.Add(kvp.Key, kvp.Value);
}
var allOnlineAircraft = _AircraftOnlineLookupManager.LookupMany(allIcaos, combinedAircraft);
foreach (var kvp in fetchedDetails)
{
var icao24 = kvp.Key;
var fetchedDetail = kvp;
BaseStationAircraft databaseAircraft = null;
BaseStationAircraftAndFlightsCount databaseAircraftAndFlights = null;
if (!aircraft.TryGetValue(icao24, out databaseAircraft))
{
aircraftAndFlightCounts.TryGetValue(icao24, out databaseAircraftAndFlights);
}
AircraftOnlineLookupDetail onlineAircraft;
allOnlineAircraft.TryGetValue(icao24, out onlineAircraft);
kvp.Detail = ApplyDatabaseRecord(
fetchedDetail.Detail,
databaseAircraftAndFlights ?? databaseAircraft,
onlineAircraft,
fetchedDetail.Aircraft,
fetchedDetail.IsFirstFetch,
databaseAircraftAndFlights != null ? databaseAircraftAndFlights.FlightsCount
: fetchedDetail.Detail != null ? fetchedDetail.Detail.FlightsCount : 0
);
}
return(true);
}
/// <summary>
/// Fetches the aircraft record from the database for the ICAO24 code passed across. If there is no
/// record for the ICAO24 code then one is created.
/// </summary>
/// <param name="localNow"></param>
/// <param name="icao24"></param>
/// <returns></returns>
private BaseStationAircraft FetchOrCreateAircraft(DateTime now, string icao24)
{
var codeBlock = _StandingDataManager.FindCodeBlock(icao24);
var result = _Database.GetOrInsertAircraftByCode(icao24, (useIcao) => {
var aircraft = new BaseStationAircraft()
{
AircraftID = 0,
ModeS = useIcao,
FirstCreated = now,
LastModified = now,
ModeSCountry = codeBlock == null || codeBlock.Country == null || codeBlock.Country.StartsWith("Unknown ", StringComparison.InvariantCultureIgnoreCase) ? null : codeBlock.Country,
};
return(aircraft);
});
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraft"></param>
public void UpdateAircraft(BaseStationAircraft aircraft)
{
if (!WriteSupportEnabled)
{
throw new InvalidOperationException("You cannot update aircraft when write support is disabled");
}
aircraft.FirstCreated = SQLiteDateHelper.Truncate(aircraft.FirstCreated);
aircraft.LastModified = SQLiteDateHelper.Truncate(aircraft.LastModified);
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
_AircraftTable.Update(_Connection, _TransactionHelper.Transaction, _DatabaseLog, aircraft);
}
}
}
/// <summary>
/// Fetches an aircraft record by its record ID.
/// </summary>
/// <param name="connection"></param>
/// <param name="transaction"></param>
/// <param name="log"></param>
/// <param name="id"></param>
/// <returns></returns>
public BaseStationAircraft GetById(IDbConnection connection, IDbTransaction transaction, TextWriter log, int id)
{
BaseStationAircraft result = null;
var preparedCommand = PrepareCommand(connection, transaction, "GetById", _GetByIdCommandText, 1);
Sql.SetParameters(preparedCommand, id);
Sql.LogCommand(log, preparedCommand.Command);
using (IDataReader reader = preparedCommand.Command.ExecuteReader()) {
int ordinal = 0;
if (reader.Read())
{
result = DecodeFullAircraft(reader, ref ordinal);
}
}
return(result);
}
/// <summary>
/// Converts a <see cref="BaseStationAircraft"/> record into an <see cref="AircraftOnlineLookupDetail"/> object.
/// </summary>
/// <param name="baseStationAircraft"></param>
/// <returns></returns>
private AircraftOnlineLookupDetail Convert(BaseStationAircraft baseStationAircraft)
{
return(IsEmptyButNotMissing(baseStationAircraft) ? null : new AircraftOnlineLookupDetail()
{
AircraftDetailId = baseStationAircraft.AircraftID,
Icao = baseStationAircraft.ModeS,
Registration = baseStationAircraft.Registration,
Country = !String.IsNullOrEmpty(baseStationAircraft.Country) ? baseStationAircraft.Country : baseStationAircraft.ModeSCountry,
Manufacturer = baseStationAircraft.Manufacturer,
Model = baseStationAircraft.Type,
ModelIcao = baseStationAircraft.ICAOTypeCode,
Operator = baseStationAircraft.RegisteredOwners,
OperatorIcao = baseStationAircraft.OperatorFlagCode,
Serial = baseStationAircraft.SerialNo,
YearBuilt = ConvertYearBuilt(baseStationAircraft.YearBuilt),
CreatedUtc = ConvertToUtc(baseStationAircraft.FirstCreated),
UpdatedUtc = ConvertToUtc(baseStationAircraft.LastModified),
});
}
/// <summary>
/// Returns the WHERE portion of an SQL statement contains the fields describing the criteria passed across.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
/// <returns></returns>
private string GetFlightsCriteria(BaseStationAircraft aircraft, SearchBaseStationCriteria criteria)
{
StringBuilder result = new StringBuilder();
if (aircraft != null)
{
AddCriteria(result, "f.[AircraftID]", " = ?");
}
if (!String.IsNullOrEmpty(criteria.Callsign))
{
AddCriteria(result, "f.[Callsign]", " = ?");
}
if (criteria.FromDate.Year != DateTime.MinValue.Year)
{
AddCriteria(result, "f.[StartTime]", " >= ?");
}
if (criteria.ToDate.Year != DateTime.MaxValue.Year)
{
AddCriteria(result, "f.[StartTime]", " <= ?");
}
if (!String.IsNullOrEmpty(criteria.Operator))
{
AddCriteria(result, "a.[RegisteredOwners]", " = ?");
}
if (!String.IsNullOrEmpty(criteria.Registration))
{
AddCriteria(result, "a.[Registration]", " = ?");
}
if (!String.IsNullOrEmpty(criteria.Icao))
{
AddCriteria(result, "a.[ModeS]", " = ?");
}
if (!String.IsNullOrEmpty(criteria.Country))
{
AddCriteria(result, "a.[ModeSCountry]", " = ?");
}
if (criteria.IsEmergency)
{
AddCriteria(result, "f.[HadEmergency]", " <> 0");
}
return(result.ToString());
}
public void AircraftDetailFetcher_Fetched_Not_Raised_If_Aircraft_Record_Unchanged_After_Interval_Has_Elapsed()
{
_DatabaseAircraftAndFlights = new BaseStationAircraftAndFlightsCount()
{
ModeS = "ABC123"
};
_Fetcher.RegisterAircraft(_Aircraft.Object);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
_DatabaseAircraft = new BaseStationAircraft()
{
ModeS = "ABC123"
};
_Clock.UtcNowValue = _Clock.UtcNowValue.AddMilliseconds(IntervalMilliseconds);
_Heartbeat.Raise(r => r.SlowTick += null, EventArgs.Empty);
Assert.AreEqual(1, _FetchedHandler.CallCount);
}
public void AircraftDetailFetcher_Fetched_Raised_If_Picture_Found_But_Database_Record_Unchanged()
{
_DatabaseAircraft = _DatabaseAircraftAndFlights = new BaseStationAircraftAndFlightsCount()
{
ModeS = "ABC123", Registration = "ABC"
};
_PictureManagerReg = null;
_Fetcher.RegisterAircraft(_Aircraft.Object);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
_Clock.UtcNowValue = _Clock.UtcNowValue.AddMilliseconds(IntervalMilliseconds);
_PictureManagerReg = "ABC";
_PictureManagerIcao24 = "ABC123";
_Heartbeat.Raise(r => r.SlowTick += null, EventArgs.Empty);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
Assert.AreEqual(2, _FetchedHandler.CallCount);
Assert.AreSame(_PictureDetail, _FetchedHandler.Args.Value.Picture);
}
/// <summary>
/// Copies the content of an IDataReader containing an aircraft's information into an object.
/// </summary>
/// <param name="reader"></param>
/// <param name="ordinal"></param>
/// <returns></returns>
public static BaseStationAircraft DecodeFullAircraft(IDataReader reader, ref int ordinal)
{
BaseStationAircraft result = new BaseStationAircraft();
result.AircraftClass = Sql.GetString(reader, ordinal++);
result.AircraftID = Sql.GetInt32(reader, ordinal++);
result.Country = Sql.GetString(reader, ordinal++);
result.DeRegDate = Sql.GetString(reader, ordinal++);
result.Engines = Sql.GetString(reader, ordinal++);
result.FirstCreated = Sql.GetDateTime(reader, ordinal++);
result.GenericName = Sql.GetString(reader, ordinal++);
result.ICAOTypeCode = Sql.GetString(reader, ordinal++);
result.LastModified = Sql.GetDateTime(reader, ordinal++);
result.Manufacturer = Sql.GetString(reader, ordinal++);
result.ModeS = Sql.GetString(reader, ordinal++);
result.ModeSCountry = Sql.GetString(reader, ordinal++);
result.OperatorFlagCode = Sql.GetString(reader, ordinal++);
result.OwnershipStatus = Sql.GetString(reader, ordinal++);
result.PopularName = Sql.GetString(reader, ordinal++);
result.PreviousID = Sql.GetString(reader, ordinal++);
result.RegisteredOwners = Sql.GetString(reader, ordinal++);
result.Registration = Sql.GetString(reader, ordinal++);
result.SerialNo = Sql.GetString(reader, ordinal++);
result.Status = Sql.GetString(reader, ordinal++);
result.Type = Sql.GetString(reader, ordinal++);
result.CofACategory = Sql.GetString(reader, ordinal++);
result.CofAExpiry = Sql.GetString(reader, ordinal++);
result.CurrentRegDate = Sql.GetString(reader, ordinal++);
result.FirstRegDate = Sql.GetString(reader, ordinal++);
result.InfoUrl = Sql.GetString(reader, ordinal++);
result.Interested = Sql.GetBool(reader, ordinal++);
result.MTOW = Sql.GetString(reader, ordinal++);
result.PictureUrl1 = Sql.GetString(reader, ordinal++);
result.PictureUrl2 = Sql.GetString(reader, ordinal++);
result.PictureUrl3 = Sql.GetString(reader, ordinal++);
result.TotalHours = Sql.GetString(reader, ordinal++);
result.UserNotes = Sql.GetString(reader, ordinal++);
result.UserTag = Sql.GetString(reader, ordinal++);
result.YearBuilt = Sql.GetString(reader, ordinal++);
return(result);
}
/// <summary>
/// Fetches the aircraft record from the database for the ICAO24 code passed across. If there is no
/// record for the ICAO24 code then one is created.
/// </summary>
/// <param name="localNow"></param>
/// <param name="icao24"></param>
/// <returns></returns>
private BaseStationAircraft FetchOrCreateAircraft(DateTime now, string icao24)
{
var result = _Database.GetAircraftByCode(icao24);
if (result == null)
{
var codeBlock = _StandingDataManager.FindCodeBlock(icao24);
result = new BaseStationAircraft()
{
AircraftID = 0,
ModeS = icao24,
FirstCreated = now,
LastModified = now,
ModeSCountry = codeBlock == null ? null : codeBlock.Country,
};
_Database.InsertAircraft(result);
}
return(result);
}
public SingleAircraftSaveResultsJson Save([FromBody] BaseStationAircraft aircraft)
{
var result = new SingleAircraftSaveResultsJson();
var plugin = Plugin.Singleton;
try {
result.Aircraft = aircraft;
if (CustomConvert.Icao24(aircraft?.ModeS) > 0)
{
aircraft.Registration = aircraft?.Registration?.ToUpper().Trim();
aircraft.ICAOTypeCode = aircraft?.ICAOTypeCode?.ToUpper().Trim();
aircraft.OperatorFlagCode = aircraft?.OperatorFlagCode?.ToUpper().Trim();
aircraft.LastModified = DateTime.Now;
if (aircraft.UserString1 == "Missing")
{
aircraft.UserString1 = null;
}
if (aircraft.AircraftID == 0)
{
aircraft.FirstCreated = aircraft.LastModified;
plugin.BaseStationDatabase.InsertAircraft(aircraft);
}
else
{
plugin.BaseStationDatabase.UpdateAircraft(aircraft);
}
plugin.IncrementUpdateCount();
plugin.UpdateStatusTotals();
}
} catch (Exception ex) {
var aircraftID = aircraft == null ? "<no aircraft>" : aircraft.AircraftID.ToString();
var icao = aircraft == null ? "<no aircraft>" : aircraft.ModeS;
result.Exception = plugin.LogException(ex, "Exception caught during DatabaseEditor SingleAircraftSave ({0}/{1}): {2}", aircraftID, icao, ex.ToString());
}
return(result);
}
public void AircraftDetailFetcher_Fetched_Raised_If_Aircraft_Record_Changes()
{
_DatabaseAircraftAndFlights = new BaseStationAircraftAndFlightsCount()
{
ModeS = "ABC123", FlightsCount = 52
};
_Fetcher.RegisterAircraft(_Aircraft.Object);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
_DatabaseAircraft = new BaseStationAircraft()
{
ModeS = "ABC123", Registration = "New Registration"
};
_Clock.UtcNowValue = _Clock.UtcNowValue.AddMilliseconds(IntervalMilliseconds);
_Heartbeat.Raise(r => r.SlowTick += null, EventArgs.Empty);
Assert.AreEqual(2, _FetchedHandler.CallCount);
Assert.AreEqual("New Registration", _FetchedHandler.Args.Value.Aircraft.Registration);
Assert.AreEqual(52, _FetchedHandler.Args.Value.FlightsCount);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
/// <param name="fromRow"></param>
/// <param name="toRow"></param>
/// <param name="sort1"></param>
/// <param name="sort1Ascending"></param>
/// <param name="sort2"></param>
/// <param name="sort2Ascending"></param>
/// <returns></returns>
public List <BaseStationFlight> GetFlightsForAircraft(BaseStationAircraft aircraft, SearchBaseStationCriteria criteria, int fromRow, int toRow, string sort1, bool sort1Ascending, string sort2, bool sort2Ascending)
{
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
FlightsTable.NormaliseCriteria(criteria);
List <BaseStationFlight> result = new List <BaseStationFlight>();
if (aircraft != null)
{
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
result = _FlightTable.GetForAircraft(_Connection, null, _DatabaseLog, aircraft, criteria, fromRow, toRow, sort1, sort1Ascending, sort2, sort2Ascending);
}
}
}
return(result);
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="aircraft"></param>
/// <param name="criteria"></param>
/// <returns></returns>
public int GetCountOfFlightsForAircraft(BaseStationAircraft aircraft, SearchBaseStationCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException("criteria");
}
FlightsTable.NormaliseCriteria(criteria);
int result = 0;
if (aircraft != null)
{
lock (_ConnectionLock) {
OpenConnection();
if (_Connection != null)
{
result = _FlightTable.GetCountForAircraft(_Connection, null, _DatabaseLog, aircraft, criteria);
}
}
}
return(result);
}
public void AircraftDetailFetcher_RegisterAircraft_Does_Refetch_AircraftType_If_ModelIcao_Has_Changed()
{
_DatabaseAircraftAndFlights = new BaseStationAircraftAndFlightsCount()
{
ModeS = "ABC123", ICAOTypeCode = "B747"
};
_FindAircraftType = "A380";
_Fetcher.RegisterAircraft(_Aircraft.Object);
_Heartbeat.Raise(r => r.FastTick += null, EventArgs.Empty);
_Clock.UtcNowValue = _Clock.UtcNowValue.AddMilliseconds(IntervalMilliseconds);
_DatabaseAircraft = new BaseStationAircraft()
{
ModeS = "ABC123", ICAOTypeCode = "A380"
};
_Heartbeat.Raise(r => r.SlowTick += null, EventArgs.Empty);
_StandingDataManager.Verify(r => r.FindAircraftType("B747"), Times.Once());
_StandingDataManager.Verify(r => r.FindAircraftType("A380"), Times.Once());
Assert.AreEqual(2, _FetchedHandler.CallCount);
Assert.AreSame(_AircraftType, _FetchedHandler.AllArgs[1].Value.AircraftType);
}
