public static Airfield CreateAirfield(long ID)
{
Airfield airfield = new Airfield();
airfield.id = ID;
return(airfield);
}
public static Double GetLegQuickQuote(Airfield Source, Airfield Destination, AirplaneType at)
{
try
{
Double distance = Source.GetDistaneFrom(Destination);
Double flyingtime = at.CalculateTimeToTravelDistance(distance);
Double TOTAL_QUOTE;
if (flyingtime == 0)
{
TOTAL_QUOTE = 0;
}
else
{
if (flyingtime * 2 < 2)
{
flyingtime = 2;
TOTAL_QUOTE = (flyingtime * at.GetRateForCurrentSession().HourlyRate) / 2;
}
else
{
TOTAL_QUOTE = flyingtime * at.GetRateForCurrentSession().HourlyRate;
}
}
return(TOTAL_QUOTE);
}
catch (Exception ex)
{
throw new AdminException("Airfields Not Found. Use Autocomplete feature");
}
}
public static Double GetQuickQuote(BookRequest b)
{
try
{
Double finalquote = 0;
Airfield start = null, end = null;
Int32 count = b.Legs.Count;
foreach (Leg l in b.Legs)
{
if (l.Sequence == 1)
{
start = l.Source;
}
if (l.Sequence == count)
{
end = l.Destination;
}
finalquote += GetLegQuickQuote(l.Source, l.Destination, b.PlaneType);
}
finalquote += GetLegQuickQuote(end, start, b.PlaneType);
return(finalquote);
}
catch (Exception ex)
{
throw ex;
}
}
private void NewButton_Click(object sender, RoutedEventArgs e)
{
var saveFileDialog = new SaveFileDialog()
{
Filter = "JSON files (*.json)|*.json",
InitialDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data\Airfields")
};
if (saveFileDialog.ShowDialog() == true)
{
try
{
FileName = saveFileDialog.FileName;
airfield = new Airfield();
Save_Airfield(sender, e);
}
catch
{
MessageBox.Show("Failure creating new airfield");
return;
}
DisplayGraph();
ReloadAirfieldButton.IsEnabled = true;
SaveAirfieldButton.IsEnabled = true;
AddTaxiPathButton.IsEnabled = true;
DisplayRealGraphButton.IsEnabled = true;
ShowMarkerImport.IsEnabled = true;
NewButton.IsEnabled = false;
AirfieldInfoButton.IsEnabled = true;
ShowNodeList.IsEnabled = true;
ShowEdgeList.IsEnabled = true;
}
}
public async Task DeleteAirfield(Airfield airfield, DateTime upDateTime)
{
Data.RemoveAirfield(airfield);
await PerformDataUpdateAction((flightservice) => flightservice.DeleteAirfield(airfield),
airfield,
upDateTime);
}
private void Load_Airfield(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog
{
Filter = "JSON files (*.json)|*.json",
InitialDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data\Airfields")
};
if (openFileDialog.ShowDialog() == true)
{
try
{
FileName = openFileDialog.FileName;
airfield = JsonConvert.DeserializeObject <Airfield>(File.ReadAllText(FileName));
ReloadAirfieldButton.IsEnabled = true;
SaveAirfieldButton.IsEnabled = true;
AddTaxiPathButton.IsEnabled = true;
DisplayRealGraphButton.IsEnabled = true;
DisplayGraph();
} catch (Exception _)
{
MessageBox.Show("Error reading Airfield JSON", "Deserialization Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
public static double DistanceToAirfield(Vessel vessel, Airfield airfield)
{
if (vessel == null)
{
return(float.MaxValue);
}
return(DistanceFromTo(vessel.longitude, vessel.latitude, airfield.coords.longitude, airfield.coords.latitude, vessel.mainBody.Radius));
}
public static ListSet GetAirfields(String text)
{
ListSet aset = new ListSet();
if (text.Contains("(") && text.Contains(")"))
{
String id = text.Substring(text.LastIndexOf("(") + 1, text.LastIndexOf(")") - text.LastIndexOf("(") - 1);
if (id.Contains("Lat:") && id.Contains("Long:"))
{
Airfield a = new Airfield();
a.ICAOCODE = "T-T" + RandomPassword.Generate(5);
a.AirfieldName = text.Remove(text.IndexOf(",")).Trim();
a.Country = text.Substring(text.IndexOf(",") + 1, text.IndexOf("(") - text.IndexOf(",") - 1).Trim();
foreach (String l in id.Split(",".ToCharArray()))
{
Double temp;
if (l.Contains("Lat:"))
{
temp = Double.Parse(l.Substring(l.LastIndexOf(":") + 1));
string[] parts = DDtoDMS(temp, CoordinateType.latitude).Split(".".ToCharArray());
a.LattitudeDegrees = Int32.Parse(parts[0]);
a.LattitudeMinutes = Int32.Parse(parts[1]);
a.NS = Char.Parse(parts[2]);
}
else if (l.Contains("Long:"))
{
temp = Double.Parse(l.Substring(l.LastIndexOf(":") + 1));
string[] parts = DDtoDMS(temp, CoordinateType.longitude).Split(".".ToCharArray());
a.LongitudeDegrees = Int32.Parse(parts[0]);
a.LongitudeMinutes = Int32.Parse(parts[1]);
a.EW = Char.Parse(parts[2]);
}
}
aset.Add(a);
}
else
{
Airfield a = AirfieldDAO.FindAirfieldByID(id);
aset.Add(a);
}
}
else
{
aset.AddAll(SearchAifields(text));
if (aset.Count == 0)
{
String[] keywords = text.Split(", ".ToCharArray());
foreach (String s in keywords)
{
if (s.Length >= 3)
{
aset.AddAll(SearchAifields(s));
}
}
}
}
return(aset);
}
public NodeListWindow(MainWindow parentwindow, Airfield airfield)
{
InitializeComponent();
ParentWindow = parentwindow;
Airfield = airfield;
RefreshButton_Click(this, new RoutedEventArgs());
}
/// <summary>
/// Some Airfields will have special considerations. For example some will only switch end
/// if the wind speed is high enough. For the moment we will stick with wind direction.
/// </summary>
/// <param name="airfield"></param>
/// <returns>A list of active runways</returns>
public static List <Runway> GetActiveRunways(Airfield airfield)
{
var activeRunways = GetActiveRunwaysByWind(airfield);
if (activeRunways.Count == 0 && airfield.Runways.Count > 0)
{
throw new NoActiveRunwaysFoundException($"Could not find active runways for {airfield.Name} with wind heading {airfield.WindHeading}");
}
return(activeRunways);
}
public override bool Equals(object obj)
{
Airfield airfield = obj as Airfield;
if (airfield == null)
{
return(false);
}
return(id == airfield.id);
}
public void ConcreteSimpleBuilderSetsUpParamsCorrectly()
{
var airfield = new Airfield();
var builder = new SpitfireWarplaneBuilder();
airfield.Construct(builder);
var warplane = builder.Warplane;
Assert.AreEqual("Supermarine Spitfire", warplane.Name);
}
public void ShouldReturnExistingAirfieldOnSave()
{
var Airfield = new Airfield {
Id = 7, Name = "Airfield"
};
var result = GetTestSubject().Save(Airfield);
result.Should().BeEquivalentTo(Airfield);
}
public AirfieldInformationWindow(Airfield airfield, MainWindow parent)
{
InitializeComponent();
this.airfield = airfield;
this.parent = parent;
NameBox.Text = airfield.Name ?? "";
LatBox.Text = airfield.Latitude.ToString();
LongBox.Text = airfield.Latitude.ToString();
AltBox.Text = airfield.Altitude.ToString();
}
private void Reload_Airfield(object sender, RoutedEventArgs e)
{
try {
airfield = JsonConvert.DeserializeObject <Airfield>(File.ReadAllText(FileName));
DisplayGraph();
}
catch (Exception _)
{
MessageBox.Show("Error reading Airfield JSON", "Deserialization Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public static Airfield FindAirfieldByID(String ICAOCODE)
{
try
{
Airfield a = NHibernateHelper.GetCurrentSession().Load <Airfield>(ICAOCODE);
return(a);
}
catch (Exception ex)
{
throw new Exception("Airfields Not Found. Use Autocomplete feature.");
}
}
public EdgeEditorWindow(MainWindow parent, Airfield airfield)
{
InitializeComponent();
ParentWindow = parent;
Airfield = airfield;
//Populate NodeList
foreach (var x in Airfield.NavigationGraph.Vertices)
{
NodeList.Items.Add(x);
}
}
public void ShouldReturnNewAirfieldOnSave()
{
var newAirfield = new Airfield {
Name = "NewAirfield"
};
AirfieldDbSet.Setup(m => m.Add(newAirfield)).Returns(newAirfield);
Context.Setup(m => m.SaveChanges());
var result = GetTestSubject().Save(newAirfield);
Context.Verify();
}
public void ShouldReturnAnotherNewAirfieldOnSave()
{
var newAirfield = new Airfield {
Name = "AnotherNewAirfield"
};
AirfieldDbSet.Setup(m => m.Add(newAirfield)).Returns(newAirfield);
Context.Setup(m => m.SaveChanges());
var result = GetTestSubject().Save(newAirfield);
result.Id.Should().Be(4);
}
public static Airfield FindExactAirfield(Airfield a)
{
ICriteria cr = NHibernateHelper.GetCurrentSession().CreateCriteria(typeof(Airfield));
cr.Add(Restrictions.Eq("AirfieldName", a.AirfieldName));
cr.Add(Restrictions.Eq("LattitudeDegrees", a.LattitudeDegrees));
cr.Add(Restrictions.Eq("LattitudeMinutes", a.LattitudeMinutes));
cr.Add(Restrictions.Eq("NS", a.NS));
cr.Add(Restrictions.Eq("LongitudeDegrees", a.LongitudeDegrees));
cr.Add(Restrictions.Eq("LongitudeMinutes", a.LongitudeMinutes));
cr.Add(Restrictions.Eq("EW", a.EW));
return(cr.UniqueResult <Airfield>());
}
public static void SetDestinationAirfield(Airfield airfield)
{
if (airfield != null)
{
Log.Info("set navigation airfield to " + airfield);
destinationAirfield = airfield;
Update();
}
else
{
Log.Info("set navigation airfield cleared");
ResetNavigation();
}
}
private Airfield GetOrCreateAirfield(AirfieldDirectionEnum airfieldDirection)
{
var matchingAirfield = this.Trip.Airfields.SingleOrDefault(a => a.AirfieldDirection == airfieldDirection);
if (matchingAirfield == null)
{
var newAirfield = new Airfield();
matchingAirfield = new TripAirfield(this.Trip, newAirfield, airfieldDirection);
this.Trip.Airfields.Add(matchingAirfield);
}
return(matchingAirfield.Airfield);
}
public static Airfield SaveAirfield(Airfield a)
{
Airfield at = AirfieldDAO.FindExactAirfield(a);
if (at != null)
{
return(at);
}
else
{
a.ICAOCODE = "T-T" + GetAutoassignedNumberForTemporary();
at = AirfieldDAO.AddAirfield(a);
return(at);
}
}
private static List <Runway> GetActiveRunwaysByHeading(Airfield airfield)
{
var activeRunways = new List <Runway>();
foreach (var runway in airfield.Runways)
{
var wH = airfield.WindHeading == -1 ? 90 : airfield.WindHeading;
var rH = runway.Heading;
if (Math.Min((wH - rH) < 0 ? wH - rH + 360 : wH - rH, (rH - wH) < 0 ? rH - wH + 360 : rH - wH) < 90)
{
activeRunways.Add(runway);
}
}
return(activeRunways);
}
public static ListSet SearchAifields(String text)
{
ListSet aset = new ListSet();
IList <Airfield> alistbyname = AirfieldDAO.FindByAirfieldName(text, "Start");
if (alistbyname.Count > 0)
{
foreach (Airfield a in alistbyname)
{
aset.Add(a);
}
}
Airfield abyicao = AirfieldDAO.FindAirfieldByICAO(text);
if (abyicao != null)
{
aset.Add(abyicao);
}
Airfield abyiata = AirfieldDAO.FindAirfieldByIATA(text);
if (abyiata != null)
{
aset.Add(abyiata);
}
IList <Airfield> alistbycity = AirfieldDAO.FindAirfieldByCity(text, "");
if (alistbycity.Count > 0)
{
foreach (Airfield a in alistbycity)
{
aset.Add(a);
}
}
if (aset.Count == 0)
{
IList <Airfield> alistbystate = AirfieldDAO.FindAirfieldByState(text, "");
if (alistbystate.Count > 0)
{
foreach (Airfield a in alistbystate)
{
aset.Add(a);
}
}
}
return(aset);
}
public void ShouldDeleteAirfieldAndFlightFromWhereFK()
{
Airfield airfield = new Airfield {
id = 1
};
OnlineDataService.InsertAirfield(airfield);
Flight flight = new Flight {
id = 1, From = airfield
};
OnlineDataService.InsertFlight(flight);
OnlineData = OnlineDataService.LoadUserData("").Result;
Target.UpdateOnlineData(OnlineDataService, LocalData, OnlineData, NewerTimeStamp);
OnlineData = OnlineDataService.LoadUserData("").Result;
Assert.IsTrue(OnlineData.Flights.Count == 0 && OnlineData.Lookups.Airfields.Count == 0);
}
private void Load_Airfield(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog
{
Filter = "JSON files (*.json)|*.json",
InitialDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data\Airfields")
};
if (openFileDialog.ShowDialog() == true)
{
try
{
FileName = openFileDialog.FileName;
airfield = JsonConvert.DeserializeObject <Airfield>(File.ReadAllText(FileName));
ReloadAirfieldButton.IsEnabled = true;
SaveAirfieldButton.IsEnabled = true;
AddTaxiPathButton.IsEnabled = true;
DisplayRealGraphButton.IsEnabled = true;
ShowMarkerImport.IsEnabled = true;
NewButton.IsEnabled = false;
AirfieldInfoButton.IsEnabled = true;
ShowNodeList.IsEnabled = true;
ShowEdgeList.IsEnabled = true;
DisplayGraph();
}
catch (Exception _)
{
MessageBox.Show("Error reading Airfield JSON", "Deserialization Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
try
{
var json = JsonConvert.SerializeObject(airfield, Formatting.Indented);
//Write to temp dir file.
File.WriteAllText(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "temp", "markers.json"), json);
}
catch (Exception _)
{
MessageBox.Show("Error writing Airfield JSON", "Serialization Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
public static async Task <IEnumerable <Airfield> > GetAirfields()
{
var airfields = new List <Airfield>();
const string command = @"SELECT name, position, altitude, coalition, heading, speed
FROM units
WHERE type = 'Ground+Static+Aerodrome'
AND name != 'FARP';";
try
{
using (var connection = new NpgsqlConnection(ConnectionString()))
{
await connection.OpenAsync();
using (var cmd = new NpgsqlCommand(command, connection))
{
DbDataReader dbDataReader = await cmd.ExecuteReaderAsync();
while (await dbDataReader.ReadAsync())
{
var point = (Point)dbDataReader[1];
var airfield = new Airfield
{
Name = dbDataReader.GetString(0),
Position = new Geo.Geometries.Point(point.Y, point.X),
Altitude = dbDataReader.GetDouble(2),
Coalition = dbDataReader.GetInt32(3),
WindHeading = (int)dbDataReader.GetDouble(4),
WindSpeed = dbDataReader.GetInt32(5)
};
airfields.Add(airfield);
}
dbDataReader.Close();
}
}
}
catch (Exception e)
{
Logger.Error(e, "Error retrieving airfields");
}
return(airfields);
}
private const int AirfieldSearchHeight = 915; // 3000ft in meters
public static async Task <List <GameObject> > GetAircraftNearAirfield(Airfield airfield)
{
var gameObjects = new List <GameObject>();
const string command = @"SELECT contact.id, contact.pilot, contact.position, contact.altitude, contact.heading
FROM units as contact
WHERE ST_DWithin(@airfield, contact.position, @radius)
AND contact.altitude < @altitude
AND contact.type LIKE 'Air+%';";
using (var connection = new NpgsqlConnection(ConnectionString()))
{
await connection.OpenAsync();
using (var cmd = new NpgsqlCommand(command, connection))
{
var position = new Point(airfield.Position.Coordinate.Longitude, airfield.Position.Coordinate.Latitude);
cmd.Parameters.AddWithValue("airfield", position);
cmd.Parameters.AddWithValue("radius", AirfieldSearchDistance);
cmd.Parameters.AddWithValue("altitude", AirfieldSearchHeight + airfield.Altitude);
DbDataReader dbDataReader = await cmd.ExecuteReaderAsync();
while (await dbDataReader.ReadAsync())
{
var point = (Point)dbDataReader[2];
var gameObject = new GameObject
{
Id = dbDataReader.GetString(0),
Pilot = dbDataReader.GetString(1),
Position = new Geo.Geometries.Point(point.Y, point.X),
Altitude = dbDataReader.GetDouble(3),
Heading = (int)dbDataReader.GetDouble(4)
};
gameObjects.Add(gameObject);
}
dbDataReader.Close();
}
}
return(gameObjects);
}
public static Int32 GetAutoassignedNumberForTemporary()
{
IList <Airfield> alist = AirfieldDAO.GetAutoassignedTemporary();
Airfield temp = null;
foreach (Airfield a in alist)
{
temp = a;
break;
}
if (temp == null)
{
return(1);
}
else
{
String no = temp.ICAOCODE.Replace("T-T", "");
return(Int32.Parse(no) + 1);
}
}