public async void CalculateTotalPriceAsync_CalculatesCorrectTotalPrice(TravelClass travelClass, int numAdults, int numChildren, decimal expectedPrice)
{
Mock <FlightPriceCalculator> mock = new Mock <FlightPriceCalculator>();
mock.SetupSequence(x => x.CalculateBasePriceAsync(It.IsAny <Flight>()))
.ReturnsAsync(100M)
.ReturnsAsync(150M);
var calculator = mock.Object;
SelectedFlights selectedFlights = new SelectedFlights()
{
Outbound = new Flight(),
Inbound = new Flight(),
TravelClass = travelClass,
NumberAdults = numAdults,
NumberChildren = numChildren
};
decimal actualPrice = await calculator.CalculateTotalPriceAsync(selectedFlights);
// Check expected and actual prices match.
Assert.Equal(expectedPrice, actualPrice);
// Check that TotalPrice property is set in selectedFlights
Assert.True(selectedFlights.Price == expectedPrice);
}
public virtual void Setup(CarData car)
{
name = car.name;
travelClass = car.travelClass;
type = car.type;
fulfillments = car.fulfillments;
}
public TravelClass UpdateTravelClass(int id, TravelClass travelClass)
{
if (id <= 0)
{
throw new ArgumentOutOfRangeException(ErrorMessages.INVALID_ID);
}
if (travelClass == null)
{
throw new ArgumentNullException(ErrorMessages.ENTITY_CANNOT_BE_NULL);
}
var travelClassToUpdate = this.travelClasses.GetById(id);
if (travelClassToUpdate != null)
{
travelClassToUpdate.Type = travelClass.Type;
travelClassToUpdate.Meal = travelClass.Meal;
travelClassToUpdate.PriorityBoarding = travelClass.PriorityBoarding;
travelClassToUpdate.ReservedSeat = travelClass.ReservedSeat;
travelClassToUpdate.EarnMiles = travelClass.EarnMiles;
travelClassToUpdate.NumberOfRows = travelClass.NumberOfRows;
travelClassToUpdate.NumberOfSeats = travelClass.NumberOfSeats;
travelClassToUpdate.Price = travelClass.Price;
travelClassToUpdate.AircraftId = travelClass.AircraftId;
travelClassToUpdate.IsDeleted = travelClass.IsDeleted;
this.travelClasses.SaveChanges();
}
return(travelClassToUpdate);
}
public Dictionary <string, string> GetParameterKeyValuePairs()
{
var result = new Dictionary <string, string>();
result["originLocationCode"] = OriginIATACode;
result["destinationLocationCode"] = DestinationIATACode;
result["departureDate"] = DepartureDate.ToString("yyyy-MM-dd");
result["adults"] = Adults.ToString();
if (ReturnDate.HasValue)
{
result["returnDate"] = ReturnDate.Value.ToString("yyyy-MM-dd");
}
if (Children.HasValue)
{
result["children"] = Children.ToString();
}
if (Infants.HasValue)
{
result["infants"] = Infants.ToString();
}
if (TravelClass.HasValue)
{
result["travelClass"] = TravelClass.ToString();
}
if (DirectFlightsOnly)
{
result["nonStop"] = DirectFlightsOnly.ToString().ToLower();
}
if (CurrencyCode != null)
{
result["currencyCode"] = CurrencyCode;
}
return(result);
}
/// <summary>
/// Edit Method of Travel Class
/// Returns a View for a given id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(int id)
{
TravelClass tc = tcmgr.FindTravelClass(id);
ViewBag.EditMessage = "";
return(View(tc));
}
public Family(string surname, float[] chances, TravelClass travelClass)
{
Surname = surname;
string firstName = Data.RandomElement(Data.FirstNames());
PassengerData passenger = new PassengerData(firstName, surname, travelClass);
blueprints.Add(passenger);
List <Relation> possibleRelations = new List <Relation>();
for (int i = 0; i < (int)Relation.LAST_ELEMENT; i++)
{
possibleRelations.Add((Relation)i);
}
Relate(passenger, possibleRelations);
foreach (float chance in chances)
{
if (Random.value < chance)
{
firstName = Data.RandomElement(Data.FirstNames());
passenger = new PassengerData(firstName, surname, travelClass);
blueprints.Add(passenger);
Relate(passenger, possibleRelations);
}
}
}
protected void CreatTravelClassBtn_Click(object sender, EventArgs e)
{
decimal price = this.GetValidPrice();
if (this.Page.IsValid && price != -1)
{
TravelClassType type;
bool isValid = Enum.TryParse(this.TravelClassTypeDropDownList.SelectedItem.Text, out type);
if (!isValid)
{
return;
}
var travelClass = new TravelClass()
{
Type = type,
Meal = this.MealTextBox.Text,
PriorityBoarding = this.PriorityBoardingCheckBox.Checked,
ReservedSeat = this.ReservedSeatCheckBox.Checked,
EarnMiles = this.EarnMilesCheckBox.Checked,
NumberOfRows = int.Parse(this.NumberOfRowsTextBox.Text),
NumberOfSeats = int.Parse(this.NumberOfSeatsTextBox.Text),
Price = price,
AircraftId = int.Parse(this.AddAircraftsDropDownList.SelectedItem.Value)
};
int id = this.TravelClassesServices.AddTravelClass(travelClass);
this.SuccessPanel.Visible = true;
this.AddedTravelClassIdLiteral.Text = id.ToString();
this.ClearFields();
}
}
public void Set(PassengerData data)
{
firstName = data.firstName;
surname = data.surname;
gender = data.gender;
travelClass = data.travelClass;
}
protected void btnAdd_Click(object sender, EventArgs e)
{
string flightName = txtName.Text;
int airlineid = int.Parse(ddlAirLine.SelectedItem.Value);
string airlinename = ddlAirLine.SelectedItem.Text;
Flight _flight = new Flight()
{
Name = flightName, AirlineForFlight = new Airline()
{
Id = airlineid, Name = airlinename
}
};
FlightManager _flightManger = new FlightManager();
try
{
foreach (RepeaterItem item in dlClass.Items)
{
TextBox txtNoOfSeats = (TextBox)item.FindControl("txtNoOfSeats");
Label lblClass = (Label)item.FindControl("lblClass");
if (txtNoOfSeats.Text.Length == 0)
{
txtNoOfSeats.Focus();
lblError.Text = "No of Seats Cannot be Empty";
break;
}
else
{
if (txtNoOfSeats != null)
{
TravelClass travelClass = (TravelClass)Enum.Parse(typeof(TravelClass), lblClass.Text.Trim());
int NoOfSeats = int.Parse(txtNoOfSeats.Text);
FlightClass _class = new FlightClass()
{
ClassInfo = travelClass, NoOfSeats = NoOfSeats
};
_flight.AddClass(_class);
}
}
}
if (_flightManger.AddFlight(_flight) == false)
{
lblError.Text = "Flight Name already exists";
}
else
{
lblError.Text = "Flight Added Successfully";
}
}
catch (FlightManagerException exc)
{
lblError.Text = exc.Message;
}
catch (Exception ex)
{
lblError.Text = ex.Message;
}
}
// Добавить билет
public void AddTicket(Int32 Seat, Double Price, Passenger Passenger, TravelClass TravelClass = TravelClass.EconomyClass)
{
Price = calculatePrice(Price, TravelClass);
if (Seat > 0 && Seat <= Plane.AircraftSeats)
{
Tickets.Add(new Ticket(Seat, Price, Passenger));
}
}
public PassengerData(string firstName, string surname, TravelClass travelClass)
{
this.firstName = firstName;
this.surname = surname;
this.travelClass = travelClass;
gender = (Gender)Random.Range(0, (int)Gender.LAST_ELEMENT);
}
public static TravelClassDto TravelClassToDto(TravelClass travelClass)
{
return(new TravelClassDto
{
TravelClassCode = travelClass.TravelClassCode,
TravelClassName = travelClass.Name
});
}
private static bool Elegible(Car car, Need task, TravelClass travelClass)
{
if (car.travelClass == travelClass)
{
return(car.fulfillments.Exists(need => need.needToFulfill == task));
}
return(false);
}
public ActionResult Edit([Bind(Include = "Id,Name,Active")] TravelClass travelClass)
{
if (ModelState.IsValid)
{
db.Entry(travelClass).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(travelClass));
}
public void SetDataCorrectly(TravelClass travelClass)
{
//Arrange
var flightRequest = new FlightRequest {
TravelClass = travelClass
};
//Act & Assert
Assert.AreEqual(flightRequest.TravelClass, travelClass);
}
public Family[] Create(TravelClass travelClass, int numberOfFamilies)
{
List <Family> families = new List <Family>();
for (int i = 0; i < numberOfFamilies; i++)
{
families.Add(CreateOne(travelClass));
}
return(families.ToArray());
}
public ActionResult Edit(TravelClass tc)
{
if (ModelState.IsValid)
{
tcmgr.EditTravelClass(tc);
TempData["EditMessage"] = "TravelClass Edited Sucessfully";
return(RedirectToAction("Index"));
}
ViewBag.EditMessage = "Something went wrong try again...";
return(View(tc));
}
public ActionResult Create([Bind(Include = "Id,Name,IsActive")] TravelClass travelClass)
{
if (ModelState.IsValid)
{
db.TravelClasses.Add(travelClass);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(travelClass));
}
public int AddTravelClass(TravelClass travelClass)
{
if (travelClass == null)
{
throw new ArgumentNullException(ErrorMessages.ENTITY_CANNOT_BE_NULL);
}
this.travelClasses.Add(travelClass);
this.travelClasses.SaveChanges();
return(travelClass.Id);
}
// GET: TravelClasses/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TravelClass travelClass = db.TravelClasses.Find(id);
if (travelClass == null)
{
return(HttpNotFound());
}
return(View(travelClass));
}
public override int GetHashCode()
{
var hashCode = 319552321;
hashCode = hashCode * -1521134295 + EqualityComparer <Flight> .Default.GetHashCode(Outbound);
hashCode = hashCode * -1521134295 + EqualityComparer <Flight> .Default.GetHashCode(Inbound);
hashCode = hashCode * -1521134295 + NumberAdults.GetHashCode();
hashCode = hashCode * -1521134295 + NumberChildren.GetHashCode();
hashCode = hashCode * -1521134295 + Price.GetHashCode();
hashCode = hashCode * -1521134295 + TravelClass.GetHashCode();
hashCode = hashCode * -1521134295 + IsReturn.GetHashCode();
return(hashCode);
}
protected void btnDelete_Command(object sender, CommandEventArgs e)
{
int id = Int32.Parse(e.CommandArgument.ToString());
using (var db = new AirlineTicketBookingDBContext())
{
var travelclass = new TravelClass()
{
Travel_Class_ID = id
};
db.TravelClasses.Attach(travelclass);
db.TravelClasses.Remove(travelclass);
db.SaveChanges();
Response.Redirect("~/Pages/ListTravelClass.aspx");
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
string name = txtName.Text;
string description = txtDescription.Text;
using (AirlineTicketBookingDBContext db = new AirlineTicketBookingDBContext())
{
var travelclass = new TravelClass()
{
Name = name,
Description = description
};
db.TravelClasses.Add(travelclass);
db.SaveChanges();
Response.Redirect("~/Pages/ListTravelClass.aspx");
}
}
public ActionResult Create(TravelClass tc)
{
if (ModelState.IsValid)
{
TravelClass DuplicateTC = tcmgr.GetTravelClass().FirstOrDefault(p => p.TravelClassName.ToLower() == tc.TravelClassName.ToLower());
if (DuplicateTC == null)
{
tcmgr.AddTravelClass(tc);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Travel Class already exists");
}
}
return(View());
}
public ActionResult DeleteConfirmed(int id)
{
TravelClass travelClass = db.TravelClasses.Find(id);
//delete Schedule travel classes
// db.ScheduleTravelClasses.RemoveRange(travelClass.ScheduleTravelClasses);
//delete train type travel class
//db.TrainTypeTravelClasses.RemoveRange(travelClass.TrainTypeTravelClasses);
//db.SaveChanges();
//db.TravelClasses.Remove(travelClass);
travelClass.IsActive = false;
db.Entry(travelClass).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Family CreateOne(TravelClass travelClass)
{
Family family = null;
string surname = Data.RandomElement(Data.surnames);
switch (travelClass)
{
case TravelClass.First:
family = new FirstClassFamily(surname, chances, firstClassFunds, firstClassIncome);
break;
case TravelClass.Second:
break;
case TravelClass.Third:
break;
}
return(family);
}
// Методы для работы с билетами
// Посчитать цену билета в зависимости от класса места
private Double calculatePrice(Double BasePrice, TravelClass TravelClass)
{
Double Price = 0.0;
switch (TravelClass)
{
case TravelClass.FirstClass:
Price = 2 * BasePrice;
break;
case TravelClass.BusinessClass:
Price = 1.5 * BasePrice;
break;
case TravelClass.ComfortClass:
Price = 1.2 * BasePrice;
break;
case TravelClass.EconomyClass:
Price = BasePrice;
break;
}
return(Price);
}
public CalculationResult CalculateEmission(DateTime effectiveDate, decimal distance, TravelClass travelClass,
bool reversal)
{
var distanceType = GetDistanceType(distance);
var factorId = FactorMapping[distanceType][travelClass];
var factorValue = context.FactorValue(effectiveDate, factorId);
if (factorValue == null)
{
var message = string.Format(Resources.FactorValueNotFound, factorId, effectiveDate);
throw new NullReferenceException(message);
}
var emissions = (factorValue*distance)*UpliftFactor;
if (reversal)
{
emissions = emissions*-1;
}
var calculationDate = context.CalculationDateForFactorId(factorId);
return new CalculationResult
{
CalculationDate = calculationDate,
ActivityGroupId = ActivityMapping[distanceType][travelClass],
Emissions = emissions
};
}
///// <summary>
///// Gets the availability of schedule for the given information
///// </summary>
///// <param name="scheduleForAvailability"></param>
///// <param name="numberOfSeats"></param>
///// <param name="dateOfJourney"></param>
///// <param name="tClass"></param>
///// <exception cref="FlightAvailabilityDAOException">Thorws when flights not available</exception>
///// <returns>True if avalable. False if not available</returns>
//public bool GetAvailabilityForSchedule(Schedule scheduleForAvailability, int numberOfSeats, DateTime dateOfJourney, TravelClass tClass)
//{
// bool isAvailable = false;
// try
// {
// Database dbConnection = GetDatabaseConnection();
// //Write code to store data into database
// DbCommand command = dbConnection.GetStoredProcCommand("CheckAvailabilityOfSchedule");
// dbConnection.AddInParameter(command, "@ScheduleId", DbType.Int64, scheduleForAvailability.ID);
// dbConnection.AddInParameter(command, "@NoOfSeats", DbType.Int32, numberOfSeats);
// dbConnection.AddInParameter(command, "@DateOfJourney", DbType.DateTime, dateOfJourney);
// dbConnection.AddInParameter(command, "@ClassId", DbType.Int32, (int)tClass);
// dbConnection.AddOutParameter(command, "@IsAvailable", DbType.Boolean, 0);
// //Execute the command
// dbConnection.ExecuteNonQuery(command);
// isAvailable = Convert.ToBoolean(dbConnection.GetParameterValue(command, "@IsAvailable"));
// }
// catch (Common.ConnectToDatabaseException ex)
// {
// throw new FlightAvailabilityDAOException("Unable to get availability of flights", ex);
// }
// catch (Exception ex)
// {
// throw new FlightAvailabilityDAOException("Unable to get availability of flights", ex);
// }
// return isAvailable;
//}
#endregion
#region Method to get the availability for a given schedule
/// <summary>
/// Gets the availability of schedule for the given information
/// </summary>
/// <param name="scheduleForAvailability"></param>
/// <param name="numberOfSeats"></param>
/// <param name="dateOfJourney"></param>
/// <param name="tClass"></param>
/// <exception cref="FlightAvailabilityDAOException">Thorws when flights not available</exception>
/// <returns>True if avalable. False if not available</returns>
public bool GetAvailabilityForSchedule(Schedule scheduleForAvailability, int numberOfSeats, DateTime dateOfJourney, TravelClass tClass)
{
bool isAvailable = false;
IDbConnection conn = null;
try
{
conn = this.GetConnection();
conn.Open();
//Write code to store data into database
IDbCommand cmd = conn.CreateCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "CheckAvailabilityOfSchedule";
IDataParameter param1 = cmd.CreateParameter();
param1.ParameterName = "@ScheduleId";
param1.Value = scheduleForAvailability.ID;
IDataParameter param2 = cmd.CreateParameter();
param2.ParameterName = "@NoOfSeats";
param2.Value = numberOfSeats;
IDataParameter param3 = cmd.CreateParameter();
param3.ParameterName = "@DateOfJourney";
param3.Value = dateOfJourney;
IDataParameter param4 = cmd.CreateParameter();
param4.ParameterName = "@ClassId";
param4.Value = (int)tClass;
IDataParameter param5 = cmd.CreateParameter();
param5.ParameterName = "@IsAvailable";
param5.Direction = ParameterDirection.Output;
param5.Value = 0;
cmd.Parameters.Add(param1);
cmd.Parameters.Add(param2);
cmd.Parameters.Add(param3);
cmd.Parameters.Add(param4);
cmd.Parameters.Add(param5);
//Execute the command
cmd.UpdatedRowSource = UpdateRowSource.OutputParameters;
cmd.ExecuteNonQuery();
isAvailable = Convert.ToBoolean(param5.Value);
}
catch (Common.ConnectToDatabaseException ex)
{
throw new FlightAvailabilityDAOException("Unable to get availability of flights", ex);
}
catch (Exception ex)
{
throw new FlightAvailabilityDAOException("Unable to get availability of flights", ex);
}
finally
{
if (conn != null && conn.State == ConnectionState.Open)
{
conn.Close();
}
}
return(isAvailable);
}
/// <summary>
/// Delete Method of Travel Class
/// Return a view for Travel Class for a given Id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Delete(int id)
{
TravelClass tc = tcmgr.FindTravelClass(id);
return(View(tc));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
try
{
long FromCityId = Convert.ToInt64(Request.QueryString["frmid"].ToString());
long ToCityId = Convert.ToInt64(Request.QueryString["toid"].ToString());
string flightclass = Request.QueryString["clss"].ToString();
int td = Convert.ToInt16(Request.QueryString["td"].ToString());
hdnTravelDirection.Value = td.ToString();
lblHeaderDepart.Text = Convert.ToDateTime(Request.QueryString["depart_date"]).ToString("ddd, dd MMM, yyyy");
lblHeaderReturn.Text = Convert.ToDateTime(Request.QueryString["return_date"]).ToString("ddd, dd MMM, yyyy");
TravelDirection traveldirection = (TravelDirection)td;
SearchInfo searchinfo = new SearchInfo();
City fromcity = new City();
searchinfo.OnwardDateOfJourney = Convert.ToDateTime(Request.QueryString["depart_date"]);
searchinfo.ReturnDateOfJourney = Convert.ToDateTime(Request.QueryString["return_date"]);
fromcity.CityId = FromCityId;
City tocity = new City();
tocity.CityId = ToCityId;
TravelClass travelclass = (TravelClass)Enum.Parse(typeof(TravelClass), flightclass);
searchinfo.FromCity = fromcity;
searchinfo.ToCity = tocity;
searchinfo.Class = travelclass;
searchinfo.Direction = traveldirection;
ISearchManager searchmanager = SearchManagerFactory.GetInstance().Create();
SearchLog searchlog = searchmanager.SearchForFlights(searchinfo);
SearchResult searchresult = searchlog.GetSearchResult(TravelDirection.OneWay);
List <TravelSchedule> lstTravelSchedule = searchresult.GetTravelSchedules();
dlOuterOnward.DataSource = lstTravelSchedule;
dlOuterOnward.DataBind();
Session["flightbookingonwardresults"] = lstTravelSchedule;
if (lstTravelSchedule.Count > 0)
{
lblOneWayFromCity.Text = lblHeaderFromCity.Text = lstTravelSchedule[0].GetSchedules()[0].RouteInfo.FromCity.Name;
lblOneWayToCity.Text = lblHeaderToCity.Text = lstTravelSchedule[0].GetSchedules()[0].RouteInfo.ToCity.Name;
}
if (traveldirection == TravelDirection.Return)
{
SearchResult searchresultreturn = searchlog.GetSearchResult(TravelDirection.Return);
List <TravelSchedule> lstTravelScheduleReturn = searchresultreturn.GetTravelSchedules();
dlOuterReturn.DataSource = lstTravelScheduleReturn;
dlOuterReturn.DataBind();
Session["flightbookingreturnresults"] = lstTravelScheduleReturn;
if (lstTravelScheduleReturn.Count > 0)
{
lblReturnFromCity.Text = lstTravelScheduleReturn[0].GetSchedules()[0].RouteInfo.FromCity.Name;
lblReturnToCity.Text = lstTravelScheduleReturn[0].GetSchedules()[0].RouteInfo.ToCity.Name;
}
}
else
{
outbound_div.Style.Add("width", "70%");
return_div.Visible = false;
lblHeaderReturn.Visible = false;
lblHeaderDateSeparator.Visible = false;
}
}
catch
{
Response.Redirect("~/Error.aspx");
}
}
}
