public void Cancel_Ticket()
{
Execute_Test(() =>
{
Flight flight = customer_facade.GetFlightById(1);
Ticket ticket = customer_facade.PurchaseTicket(customer_token, flight);
Assert.AreEqual(ticket.Id, 2);
flight = customer_facade.GetFlightById(1);
int empty_seates_before_cancellation = flight.RemainingTickets;
customer_facade.CancelTicket(customer_token, ticket);
Ticket ticket_from_db = customer_facade.GetTicketById(customer_token, ticket.Id);
Assert.AreEqual(ticket_from_db, null);
flight = customer_facade.GetFlightById(1);
int empty_seates_after_cancellation = flight.RemainingTickets;
Assert.AreEqual(empty_seates_before_cancellation + 1, empty_seates_after_cancellation);
TicketHistory ticketHistory = customer_facade.GetTicketHistoryByOriginalId(customer_token, ticket.Id);
Assert.AreEqual(ticketHistory.Id, 1);
Assert.AreEqual(ticketHistory.FlightId, ticket.Flight.Id);
Assert.AreEqual(ticketHistory.CustomerId, ticket.Customer.Id);
Assert.AreEqual(ticketHistory.CustomerFullName, ticket.Customer.FirstName + " " + ticket.Customer.LastName);
Assert.AreEqual(ticketHistory.CustomerUserName, ticket.Customer.User.UserName);
Assert.AreEqual(ticketHistory.TicketStatus, TicketStatus.Cancelled_By_Customer);
});
}
public void CancelTicket_UserTriesToCancelNonExistantTicket_ThrowsException()
{
LoggedInCustomerFacade customerFacade = GetCustomerFacade("coo", "6542");
Ticket ticket = new Ticket(4, customerFacade.LoginToken.User.Id);
Assert.ThrowsException <NullReferenceException>(new Action(() => { customerFacade.CancelTicket(customerFacade.LoginToken, ticket); }));
}
public IHttpActionResult CancelTicket([FromBody] Ticket ticket)
{
bool isAuthorized = false;
bool isCanceled = false;
Action act = () =>
{
isAuthorized = GetInternalLoginTokenInternal <Customer>(out LoginToken <Customer> loginTokenCustomer);
if (isAuthorized)
{
isCanceled = _loggedInCustomerFacade.CancelTicket(loginTokenCustomer, ticket);
}
};
ProcessExceptions(act);
if (!isAuthorized)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, $"Sorry, but you're not a customer. Ypur accsess is denied.")));
}
if (!isCanceled)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"The ticket number \"{ticket.ID}\" alredy not exists, so can't be deleted")));
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, $"The ticket number \"{ticket.ID}\" has been deleted")));
}
public void CancelTicket_UserCancelsExistingTicket()
{
LoggedInCustomerFacade customerFacade = GetCustomerFacade("doo", "68421");
Ticket ticket = new Ticket(2, customerFacade.LoginToken.User.Id);
customerFacade.CancelTicket(customerFacade.LoginToken, ticket);
}
public void CustomerFacade_CancelTicket()
{
LoggedInCustomerFacade facade = FlyingCenterSystem.GetInstance().Login(TestResource.CUSTOMER_USERNAME, TestResource.CUSTOMER_PASSWORD, out LoginTokenBase login) as LoggedInCustomerFacade;
Ticket ticket = facade.GetTicketById(19);
facade.CancelTicket(login as LoginToken <Customer>, ticket);
}
public void CancelTicket()
{
Flights f = customerFacade.GetFlightById(1);
Tickets t = customerFacade.PurchaseTicket(cus, f);
customerFacade.CancelTicket(cus, t);
Assert.AreEqual(0, t.ID);
}
public IHttpActionResult CancelTicket([FromUri] int ticketId)
{
LoginToken <Customer> token = GetLoginToken();
facade.CancelTicket(token, ticketId);
return(Ok());
}
public void CancelTicket()
{
Ticket ticket = customerFacade.GetTicketById(1);
customerFacade.CancelTicket(customer_token, ticket);
Ticket cancelled_ticket = customerFacade.GetTicketById(1);
Assert.IsNull(cancelled_ticket);
}
public void CancelTicketNullRefException()
{
Ticket ticket = _ticketDAO.Get(1);
FlightCenterSystem.Instance.Login(out FacadeBase facadeBase, out ILoginToken token, "uri321", "vzd474");
LoginToken <Customer> loginToken = (LoginToken <Customer>)token;
LoggedInCustomerFacade facade = (LoggedInCustomerFacade)facadeBase;
facade.CancelTicket(null, ticket);
}
public IHttpActionResult CancelTicket([FromBody] Ticket ticket)
{
var loginToken = GetLoginToken();
if (loginToken == null)
{
return(Unauthorized());
}
_facade.CancelTicket(loginToken, ticket);
return(Ok());
}
public IHttpActionResult CancelTicket([FromUri] int id)
{
GetLoginToken();
if (CustomerToken != null)
{
Ticket T = F.GetAllMyTickets(CustomerToken).ToList().Find(c => c.ID == id);
F.CancelTicket(CustomerToken, T);
return(Ok($"{CustomerToken.User.LastName} {CustomerToken.User.FirstName} canceled ticket No':{T.ID}"));
}
return(NotFound());
}
public IActionResult DeleteTicket([FromBody] Ticket ticket)
{
IActionResult result = SafeExecute(() =>
{
int facadeIndex = RetriveFacadeIndex();
LoggedInCustomerFacade customerFacade = (LoggedInCustomerFacade)FlyingCenterSystem.FacadeList[facadeIndex];
customerFacade.CancelTicket(customerFacade.LoginToken, ticket);
return(Ok());
});
return(result);
}
public void CancelTicket_Test()
{
Ticket ticket = _ticketDAO.Get(15);
FlightCenterSystem.Instance.Login(out FacadeBase facadeBase, out ILoginToken token, "uri321", "vzd474");
LoginToken <Customer> loginToken = (LoginToken <Customer>)token;
LoggedInCustomerFacade facade = (LoggedInCustomerFacade)facadeBase;
facade.CancelTicket(loginToken, ticket);
Flight flight = _flightDAO.Get(9);
Assert.AreEqual(flight.Remaining_Tickets, 45);
}
public async Task <ActionResult> CancleTicket(int ticket_id)
{
FlightsCenterSystem.GetInstance().login(GetLoginToken().Name, GetLoginToken().Password,
out LoginToken <Object> l, out FacadeBase f);
facade = f as LoggedInCustomerFacade;
token_customer = GetLoginToken();
User u = new UserDAOPGSQL().GetAll().FirstOrDefault(_ => _.Password == token_customer.Password && _.Username == token_customer.Name);
token_customer.User = new CustomerDAOPGSQL().GetAll().FirstOrDefault(_ => _.User_id == u.Id);
await Task.Run(() => facade.CancelTicket(token_customer, new TicketDAOPGSQL().Get(ticket_id)));
return(Ok());
}
public IHttpActionResult CancelTicket(Tickets ticket)
{
LoginToken <Customer> customerToken = customerLoginHelp.GetCustomerToken();
try
{
customerFacade.CancelTicket(customerToken, ticket);
return(Ok());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(BadRequest());
}
}
public IHttpActionResult CancelTicket([FromUri] int flightID)
{
if (flightID <= 0)
{
return(BadRequest());
}
LoginToken <Customer> token = (LoginToken <Customer>)Request.Properties["User"];
LoggedInCustomerFacade facade = (LoggedInCustomerFacade)(FlyingCenterSystem.GetFlyingCenterSystem().GetFacade(token));
Ticket t = facade._ticketDAO.GetTicketByFlightAndCustomerID(flightID, token.User.ID);
if (t == null)
{
return(StatusCode(HttpStatusCode.NoContent));
}
facade.CancelTicket(token, t);
return(Ok());
}
public IHttpActionResult CancelTicket([FromUri] int Id)
{
GetLoginToken();
try
{
Ticket ticket = customerFacade.GetMyTicket(loginToken, Id);
if (ticket.Id != 0)
{
customerFacade.CancelTicket(loginToken, ticket);
return(Ok($"Ticket {Id} canceld"));
}
return(NotFound());
}
catch (Exception)
{
return(BadRequest());
}
}
public IHttpActionResult CancelTicket([FromUri] int ticketid)
{
LoginToken <Customer> customerToken = (LoginToken <Customer>)Request.Properties["customerToken"];
LoggedInCustomerFacade custFacade = (LoggedInCustomerFacade)Request.Properties["customerFacade"];
TicketDAOMSSQL ticketDAO = new TicketDAOMSSQL();
Ticket ticket = ticketDAO.Get(ticketid);
if (ticket == null || ticket.ID <= 0)
{
return(NotFound());
}
try
{
custFacade.CancelTicket(customerToken, ticket);
return(Ok());
}
catch (Exception e)
{
return(Content(HttpStatusCode.NotAcceptable, e.Message));
}
}
public void CancelTicket()
{
Ticket ticket = new Ticket(facade.GetAllFlights()[0].Id, 10113);
facade.CancelTicket(CustomerLogin, ticket);
}
public void TestCustomerFacade()
{
ResetWhatIsNeeded();
FlyingCenterSystem flyingCenterSystem = FlyingCenterSystem.GetFlyingCenterSystem();
//sign in as a airline company
LoginToken <AirlineCompany> companyLoginToken = flyingCenterSystem.AttemptLoginAirlineCompany("company", "company");
LoggedInAirlineFacade loggedInAirlineFacade = (LoggedInAirlineFacade)flyingCenterSystem.GetFacade(companyLoginToken);
//create 4 flights
DateTime now = DateTime.Now;
loggedInAirlineFacade.CreateFlight(companyLoginToken,
new Flight(-1, companyLoginToken.User.ID, 1, 3,
now.AddHours(1), now.AddHours(2), 10, 10));
loggedInAirlineFacade.CreateFlight(companyLoginToken,
new Flight(-1, companyLoginToken.User.ID, 1, 3,
now.AddHours(2), now.AddHours(3), 10, 10));
loggedInAirlineFacade.CreateFlight(companyLoginToken,
new Flight(-1, companyLoginToken.User.ID, 1, 3,
now.AddHours(3), now.AddHours(4), 10, 10));
loggedInAirlineFacade.CreateFlight(companyLoginToken,
new Flight(-1, companyLoginToken.User.ID, 1, 3,
now.AddHours(4), now.AddHours(5), 10, 10));
IList <Flight> flights = loggedInAirlineFacade.GetFlightsByDestinationCountry(3);
//login as the customer
LoginToken <Customer> customer = flyingCenterSystem.AttemptLoginCustomer("customer", "customer");
LoggedInCustomerFacade loggedInCustomerFacade = (LoggedInCustomerFacade)flyingCenterSystem.GetFacade(customer);
//buy a ticket for 4 flights
loggedInCustomerFacade.PurchaseTicket(customer, flights[0]);
loggedInCustomerFacade.PurchaseTicket(customer, flights[1]);
loggedInCustomerFacade.PurchaseTicket(customer, flights[2]);
loggedInCustomerFacade.PurchaseTicket(customer, flights[3]);
TicketDAOMSSQL _ticketDAO = new TicketDAOMSSQL();
IList <Ticket> tickets = _ticketDAO.GetAll();
Assert.IsTrue(LookForTicket(tickets, customer.User.ID, flights[0].ID));
Assert.IsTrue(LookForTicket(tickets, customer.User.ID, flights[1].ID));
Assert.IsTrue(LookForTicket(tickets, customer.User.ID, flights[2].ID));
Assert.IsTrue(LookForTicket(tickets, customer.User.ID, flights[3].ID));
Assert.AreEqual(4, loggedInCustomerFacade.GetAllMyFlights(customer).Count);
loggedInCustomerFacade.CancelTicket(customer, tickets[0]);
loggedInCustomerFacade.CancelTicket(customer, tickets[1]);
loggedInCustomerFacade.CancelTicket(customer, tickets[2]);
loggedInCustomerFacade.CancelTicket(customer, tickets[3]);
tickets = _ticketDAO.GetAll();
Assert.IsTrue(tickets.Count == 0);
flights = loggedInAirlineFacade.GetFlightsByDestinationCountry(3);
Assert.IsTrue(flights[0].RemainingTickets == 10);
Assert.IsTrue(flights[1].RemainingTickets == 10);
Assert.IsTrue(flights[2].RemainingTickets == 10);
Assert.IsTrue(flights[3].RemainingTickets == 10);
}
public void G_CustomerFacadeTest()
{
new TestFacade().DeleteAllTables();
Customer testCustomer = new Customer("Joe", "Fin", "jf", "*****@*****.**", "111", "China", "100", "4580");
LoginToken <Administrator> token = new LoginToken <Administrator>()
{
User = new Administrator()
};
new LoggedInAdministratorFacade().CreateNewCustomer(token, testCustomer);
testCustomer.Id = new LoggedInAdministratorFacade().GetAllCustomers(token)[0].Id;
FlightCenterSystem fcs = FlightCenterSystem.GetInstance();
LoginToken <Customer> loginToken = new LoginToken <Customer>()
{
User = testCustomer
};
LoggedInCustomerFacade facade = fcs.GetFacade <Customer>(loginToken) as LoggedInCustomerFacade;
// Adding some data for testing:
new LoggedInAdministratorFacade().CreateNewAirline(token, new AirlineCompany("Air One", "airone", "*****@*****.**", "555", 1));
IList <AirlineCompany> airlines = facade.GetAllAirlineCompanies();
LoginToken <AirlineCompany> airlineToken = new LoginToken <AirlineCompany>()
{
User = new AirlineCompany()
};
new LoggedInAirlineFacade().CreateFlight(airlineToken, new Flight(airlines[0].Id, 1, 2, new DateTime(2011, 11, 11), new DateTime(2010, 10, 10), 5, 99));
new LoggedInAirlineFacade().CreateFlight(airlineToken, new Flight(airlines[0].Id, 2, 3, new DateTime(2012, 12, 12), new DateTime(2011, 11, 11), 0, 99));
new LoggedInAirlineFacade().CreateFlight(airlineToken, new Flight(airlines[0].Id, 2, 3, new DateTime(2012, 12, 12), new DateTime(2012, 12, 12), 1, 99));
new LoggedInAirlineFacade().CreateFlight(airlineToken, new Flight(airlines[0].Id, 2, 3, new DateTime(2010, 10, 10), new DateTime(2010, 10, 10), 10, 99));
IList <Flight> flights = facade.GetAllFlights();
#region Purchase ticket
Assert.ThrowsException <InvalidTokenException>(() =>
{
facade.PurchaseTicket(null, flights[0].Id);
// Null token, should cause an exception to be thrown
});
Assert.ThrowsException <NoTicketsRemainingException>(() =>
{
facade.PurchaseTicket(loginToken, flights[1].Id);
// A flight with no tickets left, should cause an exception to be thrown
});
facade.PurchaseTicket(loginToken, flights[0].Id);
IList <Ticket> tickets = new LoggedInAdministratorFacade().GetAllTickets(token);
flights = facade.GetAllFlights();
Assert.AreEqual(tickets[0].CustomerId, testCustomer.Id);
Assert.AreEqual(tickets[0].FlightId, flights[0].Id);
Assert.AreEqual(flights[0].RemainingTickets, 4);
Assert.ThrowsException <OneTicketForCustomerOnlyException>(() =>
{
facade.PurchaseTicket(loginToken, flights[0].Id);
// A customer can buy only one ticket per flight, should cause an exception to be thrown
});
#endregion
#region Cancel ticket
Assert.ThrowsException <InvalidTokenException>(() =>
{
facade.CancelTicket(null, tickets[0].Id);
// Null token, should cause an exception to be thrown
});
facade.CancelTicket(loginToken, tickets[0].Id);
tickets = new LoggedInAdministratorFacade().GetAllTickets(token);
flights = facade.GetAllFlights();
Assert.AreEqual(tickets.Count, 0);
Assert.AreEqual(flights[0].RemainingTickets, 5);
#endregion
#region Get all my flights
facade.PurchaseTicket(loginToken, flights[0].Id);
facade.PurchaseTicket(loginToken, flights[3].Id);
flights = facade.GetAllMyFlights(loginToken);
Assert.AreEqual(flights[0].AirlineCompanyId, airlines[0].Id);
Assert.AreEqual(flights[0].OriginCountryCode, 1);
Assert.AreEqual(flights[0].DestinationCountryCode, 2);
Assert.AreEqual(flights[0].DepartureTime, new DateTime(2011, 11, 11));
Assert.AreEqual(flights[0].LandingTime, new DateTime(2010, 10, 10));
Assert.AreEqual(flights[0].RemainingTickets, 4);
Assert.AreEqual(flights[1].AirlineCompanyId, airlines[0].Id);
Assert.AreEqual(flights[1].OriginCountryCode, 2);
Assert.AreEqual(flights[1].DestinationCountryCode, 3);
Assert.AreEqual(flights[1].DepartureTime, new DateTime(2010, 10, 10));
Assert.AreEqual(flights[1].LandingTime, new DateTime(2010, 10, 10));
Assert.AreEqual(flights[1].RemainingTickets, 9);
#endregion
}
