public async Task <IActionResult> RemoveItem(long id)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var item = avioCompany.PriceList.Where(t => t.PriceListIdemId == id).SingleOrDefault();
if (item != null)
{
await PriceListItemService.RemovePriceListItem(item);
return(Ok(200));
}
return(NotFound("Item not found."));
}
return(BadRequest("Company wasn't found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("No sufficient data provided."));
}
public async Task <IActionResult> GetCompanyDetails(long id)
{
AvioCompanyProfileDTO avioCompanyProfileDTO = new AvioCompanyProfileDTO();
if (ModelState.IsValid)
{
AvioCompany company = await AvioService.GetCompany(id);
AvioCompanyProfile companyProfile = new AvioCompanyProfile();
int avioCompanyRatingPicture = 0;
List <Destination> destinationList = company.Destinations;
string allDestinations = "";
for (int i = 0; i < destinationList.Count; i++)
{
allDestinations += destinationList[i].Name + ",";
}
companyProfile = await AvioService.GetCompanyProfile(id);
avioCompanyRatingPicture = (int)(Math.Round(await AvioService.GetAverageCompanyRating(id)));
avioCompanyProfileDTO.Id = company.AvioCompanyId;
avioCompanyProfileDTO.Name = companyProfile.Name;
avioCompanyProfileDTO.RatingPicture = avioCompanyRatingPicture;
avioCompanyProfileDTO.Address = companyProfile.Address;
avioCompanyProfileDTO.Description = companyProfile.PromoDescription;
avioCompanyProfileDTO.Destinations = allDestinations;
avioCompanyProfileDTO.DestinationList = destinationList;
return(Ok(new { avioCompanyProfileDTO }));
}
ModelState.AddModelError("", "Cannot retrieve user data.");
return(BadRequest(ModelState));
}
public async Task <IActionResult> UpdateCompanyProfile([FromBody] AvioCompanyProfile model)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var avioCompanyProfile = await AvioService.GetCompanyProfile(avioCompany.AvioCompanyProfileId);
avioCompanyProfile.Name = model.Name;
avioCompanyProfile.Address = model.Address;
avioCompanyProfile.PromoDescription = model.PromoDescription;
await AvioService.UpdateCompanyProfile(avioCompanyProfile);
return(Ok(200));
}
return(BadRequest("Avio company not found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("Not enough data provided."));
}
public async Task <IActionResult> RemoveTicket(long id)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var ticket = avioCompany.FastReservationTickets.Where(t => t.FRFTId == id).SingleOrDefault();
if (ticket != null)
{
await FastReservationFlightTicketService.RemoveTicket(ticket);
return(Ok(200));
}
return(NotFound("Ticket not found."));
}
else
{
return(BadRequest("Company wasn't found."));
}
}
}
return(BadRequest("No sufficient data provided."));
}
public async Task <IActionResult> CreateItem([FromBody] PriceListItemDTO model)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
PriceListItem item = new PriceListItem()
{
Name = model.Name,
Price = model.Price
};
avioCompany.PriceList.Add(item);
await AvioService.UpdateCompany(avioCompany);
return(Ok(200));
}
return(BadRequest("Company wasn't found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("Not enough data provided."));
}
public async Task <IActionResult> RemoveFlight(long id)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var flight = avioCompany.Flights.Where(f => f.FlightId == id).SingleOrDefault();
if (flight != null)
{
await FlightService.RemoveFlight(flight);
return(Ok(200));
}
return(NotFound("Flight not found."));
}
return(BadRequest("Company wasn't found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("No sufficient data provided."));
}
public async Task <IActionResult> GetCompanyReport()
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var companyRating = await AvioService.GetAverageCompanyRating(avioCompany.AvioCompanyId);
var flightRating = await AvioService.GetAverageFlightRating(avioCompany.AvioCompanyId);
var graph = await AvioService.GetLastMonthsSoldTickets(avioCompany.AvioCompanyId, 6);
var revenue = await AvioService.GetRevenue(avioCompany.AvioCompanyId);
return(Ok(new { companyRating, flightRating, graph, revenue }));
}
}
}
ModelState.AddModelError("", "Cannot retrieve user data.");
return(BadRequest(ModelState));
}
public async Task <IActionResult> CreateAvioAdmin([FromBody] RegisterAdminDTO adminDTO)
{
if (ModelState.IsValid)
{
if (await AvioAdminService.AdminExists(adminDTO.Username))
{
return(BadRequest("Admin already exists with that username."));
}
if (await CarAdminService.AdminExists(adminDTO.Username))
{
return(BadRequest("Admin already exists with that username."));
}
if (adminDTO.Password != adminDTO.ConfirmPassword)
{
return(BadRequest("Password and confirmation password don't match."));
}
RegularUser user = new RegularUser()
{
UserName = adminDTO.Username,
Status = UserStatus.Activated
};
var foundAdmin = await UserManager.FindByNameAsync(user.UserName) != null;
if (!foundAdmin)
{
var createdAdmin = await UserManager.CreateAsync(user, adminDTO.Password);
if (createdAdmin.Succeeded)
{
await UserManager.AddToRoleAsync(user, "AvioAdmin");
AvioAdmin admin = new AvioAdmin()
{
UserId = user.Id,
AvioCompanyId = (await AvioService.GetCompanyByName(adminDTO.CompanyName)).AvioCompanyId
};
if (admin.AvioCompanyId > 0)
{
await AvioAdminService.RegisterAdmin(user.Id, admin);
return(Ok(200));
}
else
{
return(BadRequest("Avio company not found."));
}
}
}
return(BadRequest("Admin already exists."));
}
return(BadRequest("No sufficient data provided."));
}
public FlightController(FlightService flightService, AvioService avioService, UserService userService,
AeroplaneService aeroplaneService, SeatService seatService)
{
FlightService = flightService;
AvioService = avioService;
UserService = userService;
AeroplaneService = aeroplaneService;
SeatService = seatService;
}
public ReservationController(UserService userService, FlightService flightService, AvioService avioService,
ReservationService reservationService, AeroplaneService aeroplaneService)
{
UserService = userService;
FlightService = flightService;
AvioService = avioService;
ReservationService = reservationService;
AeroplaneService = aeroplaneService;
}
public async Task <IActionResult> CreateFlight([FromBody] FlightDTO model)
{
if (ModelState.IsValid)
{
if (model.Departure > model.Arrival)
{
return(BadRequest("Departure cannot be before landing."));
}
if (model.Departure < DateTime.Now)
{
return(BadRequest("Departure cannot be before today's date."));
}
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
model.DepartureLocation.DestinationId = 0;
model.ArrivalLocation.DestinationId = 0;
foreach (Destination d in model.Transit)
{
d.DestinationId = 0;
}
var flight = new Flight()
{
AeroplaneId = (await AeroplaneService.GetAeroplane(user.AvioCompanyId, model.Aeroplane)).AeroplaneId,
Arrival = model.Arrival,
ArrivalLocation = model.ArrivalLocation,
Departure = model.Departure,
DepartureLocation = model.DepartureLocation,
AvioCompanyId = user.AvioCompanyId,
Price = model.Price,
Transit = model.Transit,
TravelDistance = model.TravelDistance,
TravelTime = model.TravelTime
};
avioCompany.Flights.Add(flight);
await AvioService.UpdateCompany(avioCompany);
return(Ok(200));
}
return(BadRequest("Avio company not found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("Not enough data provided."));
}
public async Task <IActionResult> GetAdmins()
{
List <AdminDTO> retVal = new List <AdminDTO>();
var avioAdmins = await AvioAdminService.GetAdmins();
foreach (AvioAdmin admin in avioAdmins)
{
var user = await AvioAdminService.GetAdminUser(admin.UserId);
if (admin.AvioCompanyId > 0)
{
var company = await AvioService.GetCompany(admin.AvioCompanyId);
if (company != null)
{
var companyProfile = await AvioService.GetCompanyProfile(company.AvioCompanyProfileId);
retVal.Add(new AdminDTO()
{
Id = user.Id,
Username = user.UserName,
AdminType = "Avio Company Admin",
Company = companyProfile.Name
});
}
}
}
var carAdmins = await CarAdminService.GetAdmins();
foreach (CarAdmin admin in carAdmins)
{
var user = await CarAdminService.GetAdminUser(admin.UserId);
if (admin.CarCompanyId > 0)
{
var company = await RentACarService.GetCompany(admin.CarCompanyId);
if (company != null)
{
var companyProfile = await RentACarService.GetCompanyProfile(company.CarCompanyProfileId);
retVal.Add(new AdminDTO()
{
Id = user.Id,
Username = user.UserName,
AdminType = "Car Company Admin",
Company = companyProfile.Name
});
}
}
}
return(Ok(retVal));
}
public SystemController(UserManager <RegularUser> userManager, UserService userService, AvioService avioService, RentACarService rentACarService,
AvioAdminService avioAdminService, CarAdminService carAdminService)
{
UserManager = userManager;
UserService = userService;
AvioService = avioService;
RentACarService = rentACarService;
AvioAdminService = avioAdminService;
CarAdminService = carAdminService;
}
public AvioAdminController(AvioService avioService, AvioAdminService avioAdminService, AeroplaneService aeroplaneService, FlightService flightService,
FastReservationFlightTicketService fastReservationFlightTicketService, PriceListItemService priceListItemService)
{
AvioService = avioService;
AvioAdminService = avioAdminService;
AeroplaneService = aeroplaneService;
FlightService = flightService;
FastReservationFlightTicketService = fastReservationFlightTicketService;
PriceListItemService = priceListItemService;
}
public UserController(UserService userService, FlightService flightService, ReservationService reservationService,
AvioService avioService, VehicleService vehicleService, RentACarService rentACarService, IConfiguration configuration)
{
_userService = userService;
_configuration = configuration;
_flightService = flightService;
_reservationService = reservationService;
_avioService = avioService;
_vehicleService = vehicleService;
_rentACarService = rentACarService;
}
public async Task <IActionResult> GetCompanyProfile()
{
List <AvioCompanyProfileDTO> avioCompanyProfileDTOList = new List <AvioCompanyProfileDTO>();
if (ModelState.IsValid)
{
List <AvioCompany> companies = await AvioService.GetCompanies();
List <AvioCompanyProfile> companiesProfile = new List <AvioCompanyProfile>();
List <double> avioCompanyRating = new List <double>();
List <int> avioCompanyRatingPicture = new List <int>();
foreach (var avioCompany in companies)
{
companiesProfile.Add(await AvioService.GetCompanyProfile(avioCompany.AvioCompanyId));
avioCompanyRating.Add(await AvioService.GetAverageCompanyRating(avioCompany.AvioCompanyId));
avioCompanyRatingPicture.Add((int)(Math.Round(await AvioService.GetAverageCompanyRating(avioCompany.AvioCompanyId))));
}
for (int i = 0; i < companies.Count; i++)
{
string allDestinations = "";
for (int j = 0; j < companies[i].Destinations.Count; j++)
{
if (j < companies[i].Destinations.Count - 1)
{
allDestinations += companies[i].Destinations[j].Name + ", ";
}
else
{
allDestinations += companies[i].Destinations[j].Name;
}
}
AvioCompanyProfileDTO acpDTO = new AvioCompanyProfileDTO()
{
Id = companies[i].AvioCompanyId,
Name = companiesProfile[i].Name,
Destinations = allDestinations,
Address = companiesProfile[i].Address,
Description = companiesProfile[i].PromoDescription,
Rating = avioCompanyRating[i],
RatingPicture = avioCompanyRatingPicture[i]
};
avioCompanyProfileDTOList.Add(acpDTO);
}
return(Ok(new { avioCompanyProfileDTOList }));
}
ModelState.AddModelError("", "Cannot retrieve user data.");
return(BadRequest(ModelState));
}
public async Task <IActionResult> RemoveAvioCompany(long id)
{
if (ModelState.IsValid)
{
var result = await AvioService.RemoveCompany(id);
if (result)
{
return(Ok(200));
}
else
{
return(BadRequest("Company wasn't found."));
}
}
return(BadRequest("No ID provided."));
}
public async Task <IActionResult> GetAvioCompanies()
{
var avioCompanies = await AvioService.GetCompanies();
List <AvioCompanyDTO> retVal = new List <AvioCompanyDTO>();
foreach (AvioCompany avioCompany in avioCompanies)
{
var avioCompanyProfile = await AvioService.GetCompanyProfile(avioCompany.AvioCompanyProfileId);
retVal.Add(new AvioCompanyDTO()
{
Id = avioCompany.AvioCompanyId,
Name = avioCompanyProfile.Name,
Address = avioCompanyProfile.Address,
Description = avioCompanyProfile.PromoDescription
});
}
return(Ok(retVal));
}
public async Task <IActionResult> GetCompanyProfile()
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
var avioCompanyProfile = await AvioService.GetCompanyProfile(avioCompany.AvioCompanyProfileId);
return(Ok(new { avioCompany, avioCompanyProfile }));
}
}
}
ModelState.AddModelError("", "Cannot retrieve user data.");
return(BadRequest(ModelState));
}
public async Task <IActionResult> CreateAvioCompany([FromBody] AvioCompanyDTO avioCompanyDTO)
{
if (ModelState.IsValid)
{
if (await AvioService.CompanyExists(avioCompanyDTO.Name))
{
return(BadRequest("Company already exists with the same name."));
}
var profile = new AvioCompanyProfile()
{
Name = avioCompanyDTO.Name,
Address = avioCompanyDTO.Address,
PromoDescription = avioCompanyDTO.Description
};
await AvioService.CreateCompany(new AvioCompany(), profile);
return(Ok(200));
}
return(BadRequest("No sufficient data provided."));
}
public async Task <IActionResult> CreateTicket([FromBody] FastReservationFlightTicketDTO ticket)
{
if (ModelState.IsValid)
{
var user = await AvioAdminService.GetCurrentUser();
if (user != null)
{
var avioCompany = await AvioService.GetCompany(user.AvioCompanyId);
if (avioCompany != null)
{
FastReservationFlightTicket frft = new FastReservationFlightTicket()
{
FlightId = ticket.FlightId,
Percent = ticket.Percent
};
if ((await FlightService.GetFlight(frft.FlightId)) == null)
{
return(BadRequest("Flight not found."));
}
avioCompany.FastReservationTickets.Add(frft);
await AvioService.UpdateCompany(avioCompany);
return(Ok(200));
}
return(BadRequest("Company wasn't found."));
}
return(Unauthorized("You must log in as an administrator of this company."));
}
return(BadRequest("Not enough data provided."));
}
public async Task <IActionResult> CreateAvioCompany([FromBody] AvioCompanyDTO avioCompanyDTO)
{
if (ModelState.IsValid)
{
if (await AvioService.CompanyExists(avioCompanyDTO.Name))
{
return(BadRequest("Company already exists with the same name."));
}
var profile = new AvioCompanyProfile()
{
Name = avioCompanyDTO.Name,
Address = avioCompanyDTO.Address,
PromoDescription = avioCompanyDTO.Description
};
// add destinations
var dest = new List <Destination>();
string[,] destinations = { { "Belgrade", "44.786568", "20.448921" },
{ "Tokyo", "35.689487", "139.691711" },
{ "New York", "40.712776", "-74.005974" },
{ "Berlin", "52.520008", "13.404954" },
{ "Rome", "41.9028", "12.4964" },
{ "Zurich", "47.3768880", "8.541694" } };
for (int j = 0; j < destinations.GetLength(0); ++j)
{
Destination destination = new Destination()
{
Name = destinations[j, 0],
Latitude = double.Parse(destinations[j, 1], CultureInfo.InvariantCulture),
Longitude = double.Parse(destinations[j, 2], CultureInfo.InvariantCulture),
};
dest.Add(destination);
}
AvioCompany company = new AvioCompany()
{
Destinations = dest
};
await AvioService.CreateCompany(company, profile);
// create planes for companies
var aeroplaneA380 = new Aeroplane()
{
AvioCompanyId = company.AvioCompanyId,
Name = "Airbus A380"
};
var aeroplane737 = new Aeroplane()
{
AvioCompanyId = company.AvioCompanyId,
Name = "Boeing 737"
};
if (!await AeroplaneService.AeroplaneExists(company.AvioCompanyId, aeroplaneA380.Name))
{
await AeroplaneService.AddAeroplane(aeroplaneA380);
}
if (!await AeroplaneService.AeroplaneExists(company.AvioCompanyId, aeroplane737.Name))
{
await AeroplaneService.AddAeroplane(aeroplane737);
}
// create seats for planes
var seatsA380 = new Seats()
{
AeroplaneId = aeroplaneA380.AeroplaneId,
SeatCount = 240,
InOneRow = 6
};
var seats737 = new Seats()
{
AeroplaneId = aeroplane737.AeroplaneId,
SeatCount = 320,
InOneRow = 8
};
if (!await SeatService.SeatsExist(aeroplaneA380.AeroplaneId))
{
await SeatService.AddSeats(seatsA380);
}
if (!await SeatService.SeatsExist(aeroplane737.AeroplaneId))
{
await SeatService.AddSeats(seats737);
}
return(Ok(200));
}
return(BadRequest("No sufficient data provided."));
}
public AvioController(AvioService avioSerivce, DestinationService destinationService)
{
AvioService = avioSerivce;
DestinationService = destinationService;
}
