public SubsidiaryAirline(Airline airline,AirlineProfile profile, AirlineMentality mentality, AirlineFocus market, AirlineLicense license,Route.RouteType routefocus)
: base(profile, mentality, market,license,routefocus)
{
this.Airline = airline;
foreach (AirlineLogo logo in this.Airline.Profile.Logos)
this.Profile.addLogo(logo);
}
public AirlineMerger(string name, Airline airline1, Airline airline2, DateTime date, MergerType type)
{
Name = name;
Airline1 = airline1;
Airline2 = airline2;
Date = date;
Type = type;
}
public AirlineMerger(string name, Airline airline1, Airline airline2, DateTime date, MergerType type)
{
this.Name = name;
this.Airline1 = airline1;
this.Airline2 = airline2;
this.Date = date;
this.Type = type;
}
public FutureSubsidiaryAirline(string name, string iata,Airport airport, Airline.AirlineMentality mentality, Airline.AirlineFocus market, Route.RouteType airlineRouteFocus, string logo)
{
this.Name = name;
this.IATA = iata;
this.PreferedAirport = airport;
this.Mentality = mentality;
this.Market = market;
this.Logo = logo;
this.AirlineRouteFocus = airlineRouteFocus;
}
public ActionResult Create(Airline airline)
{
if (ModelState.IsValid)
{
db.Airlines.Add(airline);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(airline);
}
public AirMatrixFlightMeta()
{
_airLine = new Airline();
_zeroStopPrice = new Price();
_oneStopPrice = new Price();
_moreThanTwoStopPrice = new Price();
_lowFareSelectPrice = new Price();
_zeroStopFlightList = new List<Component>();
_oneStopFlightList = new List<Component>();
_moreThanTwoStopFlightList = new List<Component>();
_needHide = false;
}
//calculates the value of facilities for an airline for use in happiness
private static double GetAirlineLuxuryLevel(Airline airline)
{
int luxuryLevel = 0;
if (airline.Alliances.Count > 0)
{
luxuryLevel = airline.Alliances.Where(a=>a.Type == Alliance.AllianceType.Full).SelectMany(a => a.Members).Select(m => m.Airline).Max(m => airline.Facilities.Sum(f => f.LuxuryLevel));
}
else
{
luxuryLevel = airline.Facilities.Sum(f => f.LuxuryLevel);
}
return luxuryLevel;
}
public void AirlineShouldSet_CorrectProperties_WhenValidArgsPassed()
{
// Arrange
string name = "Airline1";
var expectedCities = new HashSet <City>();
var expectedFlights = new HashSet <Flight>();
var airline = new Airline(name);
// Act & Assert
Assert.AreEqual(name, airline.Name);
CollectionAssert.AreEqual(expectedCities, airline.Cities);
CollectionAssert.AreEqual(expectedFlights, airline.Flights);
}
public async Task <IActionResult> GetAirline(int id)
{
var bucket = _bucketProvider.GetBucket("travel-sample");
var document = await bucket.GetDocumentAsync <Airline>(Airline.GetKey(id));
if (document.Status == ResponseStatus.KeyNotFound)
{
return(NotFound());
}
document.EnsureSuccess();
return(Ok(_mapper.Map <AirlineDto>(document.Content)));
}
//calculates employee happiness as a function of wages, discounts, and free pilots (relative to workload)
public static double GetEmployeeHappiness(Airline airline)
{
Dictionary <Airline, Double> wages = StatisticsHelpers.GetEmployeeWages();
Dictionary <Airline, Double> discounts = StatisticsHelpers.GetEmployeeDiscounts();
Dictionary <Airline, Double> unassignedPilots = StatisticsHelpers.GetUnassignedPilots();
IDictionary <Airline, Double> scaleWages = StatisticsHelpers.GetRatingScale(wages);
IDictionary <Airline, Double> scaleDiscounts = StatisticsHelpers.GetRatingScale(discounts);
IDictionary <Airline, Double> scaleUPilots = StatisticsHelpers.GetRatingScale(unassignedPilots);
double airlineWages = scaleWages[airline];
double airlineDiscounts = scaleDiscounts[airline];
double airlineUnassignedPilots = scaleUPilots[airline];
return((airlineWages * 0.7) + (airlineUnassignedPilots * 0.2) + (airlineDiscounts * 0.1));
}
//downgrades the facility for a specific type for an airline
public void downgradeFacility(Airline airline, AirportFacility.FacilityType type)
{
AirportFacility currentFacility = getAirportFacility(airline, type);
AirlineAirportFacility aaf = getAirlineAirportFacility(airline, type);
List <AirportFacility> facilities = AirportFacilities.GetFacilities(type);
facilities.Sort((delegate(AirportFacility f1, AirportFacility f2) { return(f1.TypeLevel.CompareTo(f2.TypeLevel)); }));
int index = facilities.IndexOf(getAirportFacility(airline, type));
addAirportFacility(airline, facilities[index - 1], GameObject.GetInstance().GameTime);
this.Facilities.Remove(aaf);
}
public void Airline_ToString_Returns_Standardised_Text()
{
var airline = new Airline();
airline.IataCode = "IATA";
airline.IcaoCode = "ICAO";
airline.Name = "NAME";
Assert.AreEqual("ICAO NAME", airline.ToString());
airline.IcaoCode = null;
Assert.AreEqual("IATA NAME", airline.ToString());
airline.IcaoCode = "";
Assert.AreEqual("IATA NAME", airline.ToString());
}
//calculates employee happiness as a function of wages, discounts, and free pilots (relative to workload)
public static double GetEmployeeHappiness(Airline airline)
{
Dictionary<Airline, Double> wages = StatisticsHelpers.GetEmployeeWages();
Dictionary<Airline, Double> discounts = StatisticsHelpers.GetEmployeeDiscounts();
Dictionary<Airline, Double> unassignedPilots = StatisticsHelpers.GetUnassignedPilots();
IDictionary<Airline, Double> scaleWages = StatisticsHelpers.GetRatingScale(wages);
IDictionary<Airline, Double> scaleDiscounts = StatisticsHelpers.GetRatingScale(discounts);
IDictionary<Airline, Double> scaleUPilots = StatisticsHelpers.GetRatingScale(unassignedPilots);
double airlineWages = scaleWages[airline];
double airlineDiscounts = scaleDiscounts[airline];
double airlineUnassignedPilots = scaleUPilots[airline];
return (airlineWages * 0.7) + (airlineUnassignedPilots * 0.2) + (airlineDiscounts * 0.1);
}
/// <summary>
/// Get the flights for a named airline
/// </summary>
/// <param name="airlineName"></param>
/// <param name="pageNumber"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public async Task <IAsyncEnumerable <Flight> > ListByAirlineAsync(string airlineName, int pageNumber, int pageSize)
{
IAsyncEnumerable <Flight> matches = null;
airlineName = airlineName.CleanString();
Airline airline = await _factory.Airlines
.GetAsync(m => m.Name == airlineName);
if (airline != null)
{
matches = ListAsync(m => m.AirlineId == airline.Id, pageNumber, pageSize);
}
return(matches);
}
public static void Main(string[] args)
{
//Users
var user1 = new User("Sepehr Hashemi", "9643", "+981111111111", 100000);
var user2 = new User("Sepehr Hashemi", "3312", "+981111111112", 100000);
var user3 = new User("Sepehr Hashemi", "9856", "+981111111113", 100000);
var user4 = new User("Sepehr Hashemi", "4065", "+981111111114", 100000);
var user5 = new User("Sepehr Hashemi", "1176", "+981111111115", 100000);
var user6 = new User("Sepehr Hashemi", "1327", "+981111111116", 100000);
var user7 = new User("Sepehr Hashemi", "9845", "+981111111117", 100000);
var user8 = new User("Sepehr Hashemi", "1098", "+981111111118", 100000);
var user9 = new User("Sepehr Hashemi", "8865", "+981111111119", 100000);
var user10 = new User("Sepehr Hashemi", "9010", "+981111111110", 100000);
//Airlines
var airline1 = new Airline("Mahan");
var airline2 = new Airline("IranAir");
var airline3 = new Airline("KishAir");
var airline4 = new Airline("Asemaan");
//Flights
var flight1 = new Flight("1144", airline1, 100, "Hamedan", "Mashhad", new DateTime(year: 2019, month: 3, day: 21));
var flight2 = new Flight("1217", airline2, 50, "Tehran", "Esfahan", new DateTime(year: 2019, month: 3, day: 27));
var flight3 = new Flight("4113", airline3, 100, "Rasht", "Yazd", new DateTime(year: 2019, month: 5, day: 11));
var flight4 = new Flight("9525", airline1, 70, "Tehran", "Shiraz", new DateTime(year: 2019, month: 4, day: 9));
var flight5 = new Flight("1618", airline4, 60, "Mashhad", "Tehran", new DateTime(year: 2019, month: 8, day: 15));
//Tickets
var ticket1 = new Ticket(flight1, 250000, null);
var ticket2 = new Ticket(flight3, 353000, null);
var ticket3 = new Ticket(flight2, 550000, null);
var ticket4 = new Ticket(flight1, 650000, null);
var ticket5 = new Ticket(flight1, 150000, null);
var ticket6 = new Ticket(flight4, 257000, null);
var ticket7 = new Ticket(flight3, 455000, null);
var ticket8 = new Ticket(flight5, 150000, null);
var ticket9 = new Ticket(flight5, 850000, null);
var ticket10 = new Ticket(flight5, 340000, null);
var ticket11 = new Ticket(flight2, 160000, null);
var ticket12 = new Ticket(flight1, 190000, null);
var ticket13 = new Ticket(flight2, 699000, null);
var ticket14 = new Ticket(flight5, 175000, null);
var ticket15 = new Ticket(flight1, 250000, null);
var ticket16 = new Ticket(flight4, 503000, null);
var ticket17 = new Ticket(flight2, 2450000, null);
var ticket18 = new Ticket(flight1, 225000, null);
var ticket19 = new Ticket(flight3, 655000, null);
var ticket20 = new Ticket(flight3, 750000, null);
user1.DateFilteredTickets(new DateTime(year: 2019, month: 3, day: 28), new DateTime(year: 2019, month: 3, day: 18));
}
/// <summary>
/// Gets the airlines from the database
/// </summary>
/// <exception cref="AirlineDAOException">Throws an exception if unable to get airlines</exception>
/// <returns>Returns the array of airlines from the database</returns>
public Model.Entities.AirTravel.Airline[] GetAirlines()
{
List <Airline> airlines = null;
IDbConnection conn = null;
try
{
//Execute the stored procedure to fetch the airline details
conn = this.GetConnection();
conn.Open();
IDbCommand cmd = conn.CreateCommand();
cmd.CommandText = "Select * From Airlines";
using (IDataReader reader = cmd.ExecuteReader())
{
airlines = new List <Airline>();
while (reader.Read())
{
Airline airline = new Airline();
airline.Id = int.Parse(reader["AirlineId"].ToString());
airline.Name = reader["AirlineName"].ToString();
airline.Code = reader["AirlineCode"].ToString();
airline.Logo = reader["AirlineLogo"].ToString();
airlines.Add(airline);
}
}
return(airlines.ToArray());
}
catch (ConnectToDatabaseException ex)
{
throw new AirlineDAOException("Unable to get airlines", ex);
}
catch (Exception ex)
{
throw new AirlineDAOException("Unable to get airlines", ex);
}
finally
{
if (conn != null && conn.State == ConnectionState.Open)
{
conn.Close();
}
}
}
public List <Flight> GetArrivals()
{
List <Flight> list = new List <Flight>();
//query
string query = "select f.id, f.airlineId, a.name as airlineName, date, f.departureCityId, dc.name as departureCity, f.departureTime, f.arrivalCityId, ac.name as arrivalCity, f.arrivalTime, f.status from flights as f join airlines as a on f.airlineId = a.id join cities as dc on f.departureCityId = dc.id join cities as ac on f.arrivalCityId = ac.id where f.arrivalCityId = @ID order by f.departureTime";
//command
SqlCommand command = new SqlCommand(query);
//parameters
command.Parameters.AddWithValue("@ID", _id);
//execute query
DataTable table = SqlServerConnection.ExecuteQuery(command);
//check if data is found
foreach (DataRow row in table.Rows)
{
//read columns
int id = (int)row["id"];
string airlineId = (string)row["airlineId"];
string airlineName = (string)row["airlineName"];
DateTime date = (DateTime)row["date"];
string departureCityId = (string)row["departureCityId"];
string departureCityName = (string)row["departureCity"];
DateTime departureTime = Convert.ToDateTime(row["departureTime"].ToString());
string arrivalCityId = (string)row["arrivalCityId"];
string arrivalCityName = (string)row["arrivalCity"];
DateTime arrivalTime = Convert.ToDateTime(row["arrivalTime"].ToString());
FlightStatus status = (FlightStatus)row["status"];
Airline airline = new Airline(airlineId, airlineName);
City departureCity = new City(departureCityId, departureCityName);
City arrivalCity = new City(arrivalCityId, arrivalCityName);
Flight f = new Flight();
f.Airline = airline;
f.ArrivalCity = arrivalCity;
f.ArrivalTime = arrivalTime;
f.Date = date;
f.DepartureCity = departureCity;
f.DepartureTime = departureTime;
f.Id = id;
f.Status = status;
list.Add(f);
}
return(list);
}
public async Task <Object> Upload()
{
string userId = User.Claims.First(c => c.Type == "UserID").Value;
string role = User.Claims.First(c => c.Type == "Roles").Value;
var user = await _userManager.FindByIdAsync(userId);
if (role != "aeroAdminNew" && role != "aeroAdmin")
{
return(BadRequest());
}
try
{
var file = Request.Form.Files[0];
var folderName = Path.Combine("StaticFiles", "Images");
var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName);
if (file.Length > 0)
{
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
var fullPath = Path.Combine(pathToSave, fileName);
var dbPath = Path.Combine(folderName, fileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
file.CopyTo(stream);
}
Airline airline = await _context.Airlines.FindAsync(user.Company);
airline.Image = dbPath;
_context.Entry(airline).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
catch (Exception ex)
{
return(StatusCode(500, $"Internal server error: {ex}"));
}
}
static void Main(string[] args)
{
var comp = new Airline();
List <Crewman> crewmen = new List <Crewman> {
new Crewman("pilot", "a s d"),
new Crewman("second pilot", "d s d"),
new Crewman("pilot", "a s d"),
new Crewman("second pilot", "a a d"),
new Crewman("flight attendant", "a аыв d"),
new Crewman("flight attendant", "a вапр d"),
new Crewman("flight attendant", "a ролп d"),
};
var planes = new List <Airplane>
{
new CargoAirplane(15000, 15, new List <Crewman> {
crewmen[0], crewmen[1]
}),
new CargoAirplane(15000, 45, new List <Crewman> {
crewmen[2], crewmen[3]
}),
new CargoAirplane(15000, 115, new List <Crewman> {
crewmen[0], crewmen[3]
}),
new PassengerAirplane(100, 39, new List <Crewman> {
crewmen[0], crewmen[3], crewmen[4], crewmen[5]
}),
new PassengerAirplane(150, 48, new List <Crewman> {
crewmen[0], crewmen[3], crewmen[6]
}),
};
comp.Add(planes);
var serializer = new AirlineSerializer();
serializer.SaveData("ManComp.xml", comp);
var comp2 = serializer.LoadData("ManComp.xml");
Console.WriteLine(comp);
Console.WriteLine();
Console.WriteLine(comp2);
Console.WriteLine();
Console.WriteLine(comp2[0]);
Console.WriteLine();
Console.WriteLine(comp2[1]);
Console.WriteLine();
Console.WriteLine(comp2[2]);
Console.WriteLine();
Console.WriteLine(comp2[^ 1]);
/// <summary>
/// Add a named airline, if it doesn't already exist
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public Airline Add(string name)
{
name = name.CleanString();
Airline airline = Get(a => a.Name == name);
if (airline == null)
{
airline = new Airline {
Name = name
};
_context.Airlines.Add(airline);
_context.SaveChanges();
}
return(airline);
}
public IActionResult AddNewAirline(Airline A)
{
try
{
orm.Airline.Add(A);
orm.SaveChanges();
ViewBag.Message = A.Name + "Airline Saved Successfully!";
ViewBag.Messagetype = "S";
}
catch
{
ViewBag.Message = A.Name + "Error in Saving Airline!";
ViewBag.Messagetype = "E";
}
return(View());
}
public BaseEntity BuildObject(Dictionary <string, object> row)
{
var airline = new Airline
{
Id = GetStringValue(row, DB_COL_ID),
Comercial_name = GetStringValue(row, DB_COL_COMERCIAL_NAME),
Business_name = GetStringValue(row, DB_COL_BUSINESS_NAME),
Creation_year = Convert.ToDateTime(GetDateValue(row, DB_COL_CREATION_YEAR)),
Description = GetStringValue(row, DB_COL_DESCRIPTION),
Email = GetStringValue(row, DB_COL_EMAIL),
Status = Convert.ToBoolean(GetBoolValue(row, DB_COL_STATUS)),
Request = GetStringValue(row, DB_COL_REQUEST)
};
return(airline);
}
/*
* //returns the number of free gates for an airport
* public int getNumberOfFreeGates(Airline airline)
* {
* var contracts = this.Airport.getAirlineContracts(airline).Where(c => c.ContractDate <= GameObject.GetInstance().GameTime);
*
* if (contracts.Count() == 0)
* return 0;
*
* int gates = contracts.Sum(c => c.NumberOfGates);
*
* return gates - (AirportHelpers.GetAirportRoutes(this.Airport, airline).Count / Gate.RoutesPerGate);
* }*/
//switches from one airline to another
public void switchAirline(Airline airlineFrom, Airline airlineTo)
{
List <AirportContract> contracts = this.Airport.getAirlineContracts(airlineFrom);
foreach (AirportContract contractFrom in contracts)
{
contractFrom.Airline = airlineTo;
}
airlineFrom.removeAirport(this.Airport);
if (!airlineTo.Airports.Contains(this.Airport))
{
airlineTo.addAirport(this.Airport);
}
}
public void CopyConstructor_InstanceOfAirlineClass_ShouldPass()
{
// Arrange
Airline expected = new Airline("TEST");
expected.AddFlight(new Flight("TEST", "AAA", "BBB", "1234", new DateTime(1987, 3, 3)));
expected.AddFlight(new Flight("TEST", "AAA", "BBB", "1235", new DateTime(1987, 3, 3)));
// Act
Airline actual = new Airline(expected);
// Assert
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.Flights[0], actual.Flights[0]);
Assert.Equal(expected.Flights[1], actual.Flights[1]);
}
public void CreateAirline_AddingValidAirlineToNonEmptyListOfAirlines_ShouldPassTest()
{
// Arrange
SystemManager manager = new SystemManager();
Airline expected = new Airline("DEL5");
// Act
manager.CreateAirline("DEL2");
manager.CreateAirline("DEL3");
manager.CreateAirline("DEL4");
manager.CreateAirline("DEL5");
Airline actual = manager.Airlines[3];
// Assert
Assert.Equal(expected, actual);
}
public async Task <StatusCode> Create(Airline entity)
{
Validation(entity);
var airlineEntity = await Airline.GetBy(entity.Email, entity.CountryId);
var isExist = airlineEntity != null;
if (isExist)
{
return(StatusCode.AlreadyExists);
}
await Airline.Create(entity.ToEntity());
return(StatusCode.Created);
}
public async Task <ServiceResponse <Airline> > GetSingle(int id)
{
ServiceResponse <Airline> serviceResponse = new ServiceResponse <Airline>();
Airline dbAirline = await _context.Airlines.Include(a => a.AirlineDestinations).ThenInclude(ad => ad.Destination)
.Include(a => a.Flights).ThenInclude(f => f.Reviews)
.FirstOrDefaultAsync(u => u.Id == id);
if (dbAirline == null)
{
serviceResponse.Message = "Airline not found.";
serviceResponse.Success = false;
return(serviceResponse);
}
serviceResponse.Data = dbAirline;
return(serviceResponse);
}
//sets up an airport for an airline
private static void SetupScenarioAirport(Airline airline, Airport airport, int quantity = 2)
{
for (int i = 0; i < quantity; i++)
{
if (!AirportHelpers.HasFreeGates(airport, airline))
{
AirportHelpers.RentGates(airport, airline);
}
}
AirportFacility checkinFacility = AirportFacilities.GetFacilities(AirportFacility.FacilityType.CheckIn).Find(f => f.TypeLevel == 1);
AirportFacility facility = AirportFacilities.GetFacilities(AirportFacility.FacilityType.Service).Find((delegate(AirportFacility f) { return(f.TypeLevel == 1); }));
airport.setAirportFacility(airline, facility, GameObject.GetInstance().GameTime);
airport.setAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
Airline airline = (Airline)value;
try
{
TypeConverter colorConverter = new ColorConverter();
Color c = (Color)colorConverter.ConvertFromString(airline.Profile.Color);
return(new SolidColorBrush(c));
}
catch
{
return(Brushes.White);
}
}
//calculates customer happiness as a function of average ticket price, crowding on flights, and on-time % - for an airline
public static double GetCustomerHappiness(Airline airline)
{
int negInt = -1;
Dictionary<Airline, Double> fillAverages = StatisticsHelpers.GetFillAverages();
Dictionary<Airline, Double> onTimePercent = StatisticsHelpers.GetTotalOnTime();
Dictionary<Airline, Double> ticketPPD = StatisticsHelpers.GetTotalPPD();
IDictionary<Airline, Double> scaleAvgFill = StatisticsHelpers.GetRatingScale(fillAverages);
IDictionary<Airline, Double> scaleOnTimeP = StatisticsHelpers.GetRatingScale(onTimePercent);
IDictionary<Airline, Double> scalePPD = StatisticsHelpers.GetRatingScale(ticketPPD);
double airlineAvgFill = scaleAvgFill[airline];
double airlineOTP = scaleOnTimeP[airline];
double airlinePPD = scalePPD[airline];
return ((airlinePPD * negInt + 100) * 0.4) + (airlineAvgFill * 0.2) + (airlineOTP * 0.4);
}
//sets the value for a statistics type for an airline for a year
public void setStatisticsValue(int year, Airline airline, StatisticsType type, int value)
{
lock (this.Stats)
{
AirportStatisticsValue item = this.Stats.Find(s => s.Year == year && s.Airline == airline && s.Stat.Shortname == type.Shortname);
if (item == null)
{
this.Stats.Add(new AirportStatisticsValue(airline, year, type, value));
}
else
{
item.Value = value;
}
}
}
/// <summary>
/// Adds an airline to the dictionary that the standing data mock uses when faking the "find airlines by code" call.
/// </summary>
/// <param name="airline"></param>
private void AddAirlineToStandingData(Airline airline)
{
foreach (var code in new string[] { airline.IataCode, airline.IcaoCode })
{
if (!String.IsNullOrEmpty(code))
{
List <Airline> list;
if (!_Airlines.TryGetValue(code, out list))
{
list = new List <Airline>();
_Airlines.Add(code, list);
}
list.Add(airline);
}
}
}
public Airline BuildObjectFromDataRow(DataRow row)
{
var airline = new Airline
{
Id = row.Field <string>(DB_COL_ID),
Comercial_name = row.Field <string>(DB_COL_COMERCIAL_NAME),
Business_name = row.Field <string>(DB_COL_BUSINESS_NAME),
Creation_year = row.Field <DateTime>(DB_COL_CREATION_YEAR),
Description = row.Field <string>(DB_COL_DESCRIPTION),
Email = row.Field <string>(DB_COL_EMAIL),
Status = row.Field <bool>(DB_COL_STATUS),
Request = row.Field <string>(DB_COL_REQUEST)
};
return(airline);
}
public IActionResult AddNewAirline(Airline a)
{
try
{
R.Airline.AddAsync(a);
R.SaveChangesAsync();
ViewBag.Message = a.Name + " airline saved Succeesfully";
ViewBag.MessageType = "s";
}
catch (Exception)
{
ViewBag.Message = "unable to save the Airline";
ViewBag.MessageType = "e";
}
return(View());
}
public virtual async Task <CreateResponse <ApiAirlineServerResponseModel> > Create(
ApiAirlineServerRequestModel model)
{
CreateResponse <ApiAirlineServerResponseModel> response = ValidationResponseFactory <ApiAirlineServerResponseModel> .CreateResponse(await this.AirlineModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
Airline record = this.DalAirlineMapper.MapModelToEntity(default(int), model);
record = await this.AirlineRepository.Create(record);
response.SetRecord(this.DalAirlineMapper.MapEntityToModel(record));
await this.mediator.Publish(new AirlineCreatedNotification(response.Record));
}
return(response);
}
//returns if an airline has any facilities besides a specific type
public Boolean hasFacilities(Airline airline, AirportFacility.FacilityType ftype)
{
Boolean hasFacilities = false;
foreach (AirportFacility.FacilityType type in Enum.GetValues(typeof(AirportFacility.FacilityType)))
{
if (type != ftype)
{
if (getAirportFacility(airline, type).TypeLevel > 0)
{
hasFacilities = true;
}
}
}
return(hasFacilities);
}
public Airline Get(int id)
{
Airline airline = new Airline();
using (var context = new DataContext(DataContext.ops.dbOptions))
{
airline = context.Airline.Include(theAirline => theAirline.AvailableFlightLuggage)
.Include(theAirline => theAirline.Flights).ThenInclude(flight => flight.ToDestination)
.Include(theAirline => theAirline.Flights).ThenInclude(flight => flight.FromDestination)
.Include(theAirline => theAirline.Flights).ThenInclude(flight => flight.Tickets)
.Include(theAirline => theAirline.Flights).ThenInclude(flight => flight.Seats).Include(theAirline => theAirline.AirlineDestinations)
.Where(theAirline => theAirline.AirlineId == id).SingleOrDefault();
}
return(airline);
}
public static Airline FromXml(string filename)
{
var airline = new Airline();
var serializer = new XmlSerializer(typeof(List <Plane>));
using (var stream = File.OpenRead(filename))
{
var planes = serializer.Deserialize(stream) as IEnumerable <Plane>;
if (planes != null)
{
airline._planes.AddRange(planes);
}
}
return(airline);
}
// GET: Airlines/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Airline airline = db.Airlines.Find(id);
if (airline == null)
{
return(HttpNotFound());
}
//Uncooment To deleteDoc from cosmoDB await this.client.DeleteDocumentAsync(UriFactory.CreateDocumentUri("CharterResor", "Airline", id.ToString()));
return(View(airline));
}
public Airline AddAirlinesAirlines(Airline airline)
{
_airlineRepository.Add(airline);
return airline;
}
/**
* @param Customer
* @param AirlinerForSelling
* @return
*/
public void SellAirliner(Airline Customer, Airliner AirlinerForSelling) {
// TODO implement here
return null;
}
/**
* @param Customer
* @param CargoAirplaneForSelling
* @return
*/
public void SellCargoAirplane(Airline Customer, CargoAirplane CargoAirplaneForSelling) {
// TODO implement here
return null;
}
/**
* @param Dealer
* @param DesiredCargoAirplane
* @return
*/
public void BuyCargoAirplane(Airline Dealer, CargoAirplane DesiredCargoAirplane) {
// TODO implement here
return null;
}
/**
* @param Dealer
* @param DesiredAirliner
* @return
*/
public void BuyAirliner(Airline Dealer, Airliner DesiredAirliner) {
// TODO implement here
return null;
}
//calculates human daily flights worldwide
/* public static double getHumanDailyFlights()
{
Dictionary<Airline,double> uFlights = new Dictionary<Airline,double>();
foreach (Airport airport in GameObject.GetInstance().HumanAirline.Airports)
{
double flights = AirportHelpers.GetAirportRoutes(airport).Sum(r => r.TimeTable.Entries.Count) / 7;
double hFlights = AirportHelpers.GetAirportRoutes(airport, GameObject.GetInstance().HumanAirline).Sum(r=>r.TimeTable.Entries.Count) / 7;
uFlights.Add(Airline,(hFlights/flights);
}
return hFlights /
}*/
/*===============================================================================================
* =======================score methods =====================================================*/
//this is the main method that is called once a week
public static int GetWeeklyScore(Airline airline)
{
int score = 0;
//some base score weights:
//fleet: 5 per airliner
// destinations: 2 per destination
// cash: 1 per $1,000,000
// happiness: raw value
// employee happiness: raw value
// maint, security, safety: raw values
int fleet = airline.Fleet.Count();
int destinations = airline.Airports.Count();
int cash = (int)airline.Money / 1000000;
double happiness = airline.Ratings.CustomerHappinessRating;
happiness = Math.Pow(happiness, 2) / 2;
double empHappiness = airline.Ratings.EmployeeHappinessRating;
empHappiness = Math.Pow(empHappiness, 2) / 4;
double maint = airline.Ratings.MaintenanceRating;
double security = airline.Ratings.SecurityRating;
double safety = airline.Ratings.SafetyRating;
score += (int)((fleet * 5) + (destinations * 2) + cash + happiness + empHappiness + maint + safety + security);
airline.CountedScores++;
return score;
}
public Cooperation(CooperationType type, Airline airline, DateTime built)
{
this.BuiltDate = built;
this.Airline = airline;
this.Type = type;
}
public Cooperation(CooperationType type, Airline airline, DateTime built)
{
BuiltDate = built;
Airline = airline;
Type = type;
}
public SubsidiaryAirline(Airline airline,AirlineProfile profile, AirlineMentality mentality, AirlineFocus market, AirlineLicense license,Route.RouteType routefocus)
: base(profile, mentality, market,license,routefocus)
{
this.Airline = airline;
this.Profile.Logos = this.Airline.Profile.Logos;
}
public ActionResult Edit(Airline airline)
{
if (ModelState.IsValid)
{
db.Entry(airline).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
return View(airline);
}
//returns the airlines best year in terms of score
public static int GetBestYear(Airline airline)
{
int high = 0;
int year = 0;
{
int years = GameObject.GetInstance().GameTime.Year - GameObject.StartYear;
for (int z = GameObject.StartYear; z < (z + years); z++)
{
int sc = GetScore(airline, z);
if (sc > high)
{
high = sc;
year = z;
}
}
}
return year;
}
//returns the on-time % for an airline
public static double GetOnTimePercent(Airline airline)
{
return airline.Statistics.getStatisticsValue(StatisticsTypes.GetStatisticsType("On-Time%"));
}
//returns the average employee wages for the competitors for an airlines
public static double GetAverageEmployeeWages(Airline airline)
{
var numberOfAirlines = Airlines.GetNumberOfAirlines()-1;
Dictionary<Airline, Double> airlineWages = new Dictionary<Airline, double>(GetEmployeeWages());
double totalWages = 0;
foreach (Airline competitor in Airlines.GetAllAirlines())
{
if (competitor != airline)
totalWages += GetEmployeeWages()[competitor];
}
return totalWages / numberOfAirlines;
}
//returns the fill degree for an airline
public static double GetAirlineFillAverage(Airline airline)
{
List<Double> fillDegree = (from r in airline.Routes select r.getFillingDegree()).ToList();
return fillDegree.DefaultIfEmpty(0).Average();
}
//helper method to get the score inclusively for a provided date range
public static int GetYearScore(Airline airline, int startYear, int endYear)
{
int mScore = 0;
foreach (KeyValuePair<DateTime, int> score in airline.GameScores)
{
if (score.Key.Year >= startYear && score.Key.Year <= endYear)
{
mScore += score.Value;
}
}
return mScore;
}
private void SetAirLine(AirMaterial currentFlight, AirMatrixFlightMeta currentMatrix)
{
if (flightInfohider.IsNeedToHide(currentFlight))
{
Airline airLine = new Airline();
airLine.Code = flightInfohider.ReplaceFlightCode(currentFlight);
airLine.Name = flightInfohider.ReplaceFlightName(currentFlight);
airLine.LogoUrl = LOGO_DEFAULT;
currentMatrix.AirLine = airLine;
}
else
{
currentMatrix.AirLine = ((AirProfile)currentFlight.Profile).Airlines[0];
}
}
//helper method to get a score for a given month of a given year
public static int GetScore(Airline airline, int year, int month)
{
int mScore = 0;
foreach (KeyValuePair<DateTime, int> score in airline.GameScores)
{
if (score.Key.Month == month && score.Key.Year == year)
{
mScore += score.Value;
}
}
return mScore;
}
/**
* @param CurrentFlight
* @param CurrentAirline
* @return
*/
public bool BuyTicket(PassengerFlight CurrentFlight, Airline CurrentAirline) {
// TODO implement here
return False;
}
public static int GetScore(Airline airline)
{
int mScore = 0;
foreach (KeyValuePair<DateTime, int> score in airline.GameScores)
{
mScore += score.Value;
}
return mScore;
}
/**
* @param AirlineToLeave
* @return
*/
public bool Leave(Airline AirlineToLeave) {
// TODO implement here
return False;
}
//just a helper method to get a score for a given year
public static int GetScore(Airline airline, int year)
{
int yScore = 0;
foreach (KeyValuePair<DateTime, int> score in airline.GameScores)
{
if (score.Key.Year == year)
{
yScore += score.Value;
}
}
return yScore;
}
