// GET: Airports/Create
public ActionResult AirportCreate()
{
AirportViewModel airport = new AirportViewModel();
airport.Cities = _cityService.GetCities();
return(PartialView(airport));
}
public IEnumerable <AirportViewModel> Retreive()
{
using (var context = new ABS())
{
List <Airport> airports = new List <Airport>();
airports = context.Airports.ToList();
if (airports == null)
{
return(null);
}
{
List <AirportViewModel> airportsDisplay = new List <AirportViewModel>();
foreach (var airport in airports)
{
var airportDisplay = new AirportViewModel()
{
AirportId = airport.AirportId,
Name = airport.Name
};
airportsDisplay.Add(airportDisplay);
}
return(airportsDisplay);
}
}
}
public JsonAirport Airportslist()
{
JsonAirport jsonAirport = new JsonAirport();
List <AirportViewModel> airportlinklistobj = new List <AirportViewModel>();
try
{
var listairports = _airport.Tolist();
foreach (var item in listairports)
{
AirportViewModel airportlistobj = new AirportViewModel();
airportlistobj.Name = item.Name;
airportlistobj.AirportId = item.Id;
airportlistobj.Gallery = _gallery.FindById(item.GalleryId).Name;
airportlistobj.Abbreviation = item.Abbreviation;
airportlinklistobj.Add(airportlistobj);
}
jsonAirport.result = airportlinklistobj;
return(jsonAirport);
}
catch (Exception)
{
return(jsonAirport);
}
}
public IActionResult Edit(int id, [Bind("Id,Name,GpsCoords")] AirportViewModel airportvm)
{
if (id != airportvm.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_airportService.Save(airportvm.Airport);
}
catch (DbUpdateConcurrencyException)
{
if (!AirportExists(airportvm.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(airportvm));
}
public void CallAddAirportOnAirportServiceWIthExpectedAirport()
{
// Arrange
var countryService = new Mock <ICountryService>();
var airlineService = new Mock <IAirlineService>();
var flightService = new Mock <IFlightService>();
var mappingService = new Mock <IMappingService>();
var cityService = new Mock <ICityService>();
var airportService = new Mock <IAirportService>();
var jobService = new Mock <IJobService>();
var adminController = new AdminController(countryService.Object, mappingService.Object, cityService.Object, airlineService.Object, airportService.Object, flightService.Object, jobService.Object);
var expectedAirportVIewModel = new AirportViewModel()
{
Id = 1
};
var airport = new Airport()
{
Id = 1
};
mappingService.Setup(m => m.Map <Airport>(expectedAirportVIewModel)).Returns(airport);
// Act
adminController.AddAirport(expectedAirportVIewModel);
// Assert
airportService.Verify(c => c.AddAirport(airport), Times.Once);
}
public void ReturnIndexView_WhenEverythingIsDone()
{
// Arrange
var countryService = new Mock <ICountryService>();
var airlineService = new Mock <IAirlineService>();
var flightService = new Mock <IFlightService>();
var mappingService = new Mock <IMappingService>();
var cityService = new Mock <ICityService>();
var airportService = new Mock <IAirportService>();
var jobService = new Mock <IJobService>();
var adminController = new AdminController(countryService.Object, mappingService.Object, cityService.Object, airlineService.Object, airportService.Object, flightService.Object, jobService.Object);
var expectedAirportVIewModel = new AirportViewModel()
{
Id = 1
};
var airport = new Airport()
{
Id = 1
};
mappingService.Setup(m => m.Map <Airport>(expectedAirportVIewModel)).Returns(airport);
// Act and Assert
adminController.WithCallTo(a => a.AddAirport(expectedAirportVIewModel))
.ShouldRenderView("Index");
}
public MainWindow()
{
InitializeComponent();
var airportViewModel = new AirportViewModel();
this.DataContext = airportViewModel;
}
public ActionResult Create([Bind] AirportViewModel airportView)
{
if (ModelState.IsValid)
{
airportService.Save(airportView.Id, airportView.Name, airportView.Address, airportView.Country);
}
return(RedirectToAction("Index"));
}
public ActionResult AirportEdit([Bind(Include = "Id,Name,Code,CityId")] AirportViewModel airport)
{
if (ModelState.IsValid)
{
_airportService.UpdateAirport(Mapper.Map <AirportViewModel, Airport>(airport));
return(RedirectToAction("AirportIndexFull"));
}
return(PartialView(airport));
}
public IActionResult Create([Bind("Id,Name,GpsCoords")] AirportViewModel airportvm)
{
if (ModelState.IsValid)
{
_airportService.Save(airportvm.Airport);
return(RedirectToAction(nameof(Index)));
}
return(View(airportvm));
}
/// <summary>
/// Airport List redirection
/// </summary>
/// <returns></returns>
public IActionResult Index()
{
var List = _areportrepository.Airports;
var mv = new AirportViewModel()
{
Airports = List
};
return(View(mv));
}
public int Create(AirportViewModel model)
{
if (ModelState.IsValid)
{
var airport = _mapper.Map <Airport>(model);
_repository.Insert(airport);
return(airport.Id);
}
return(0);
}
public async Task <ActionResult> UpdateAirport(int id, [FromBody] AirportViewModel model)
{
Response <string> updateResult = await _airportService.UpdateAirportAsync(id, model);
if (updateResult.Success == false)
{
return(BadRequest(updateResult));
}
return(Ok(updateResult));
}
public ActionResult AirportEditFull(int id)
{
AirportViewModel airport = Mapper.Map <Airport, AirportViewModel>(_airportService.GetAirport(id));
if (airport == null)
{
return(HttpNotFound());
}
airport.Cities = _cityService.GetCities();
return(View("AirportEdit", airport));
}
public ActionResult AirportCreate([Bind(Include = "Id,Name,Code,CityId")] AirportViewModel airport)
{
if (ModelState.IsValid)
{
airport.City = _cityService.GetCity(airport.CityId);
_airportService.CreateAirport(Mapper.Map <AirportViewModel, Airport>(airport));
return(RedirectToAction("AirportIndexFull"));
}
airport.Cities = _cityService.GetCities();
return(View(airport));
}
public async Task <IActionResult> Create(AirportViewModel airportViewModel, CancellationToken cancellationToken)
{
Airport airport = new Airport()
{
Name = airportViewModel.Name,
Latitude = airportViewModel.Latitude,
Longitude = airportViewModel.Longitude
};
await airportManager.AddAirportAsync(airport, cancellationToken);
return(RedirectToAction("Index"));
}
public ActionResult AddAirport(AirportViewModel airport)
{
if (!this.ModelState.IsValid)
{
return(RedirectToAction(nameof(AdminController.Index)));
}
var airportModel = base.MappingService.Map <Airport>(airport);
base.AirportService.AddAirport(airportModel);
return(View("Index"));
}
public ActionResult Edit(int id, [Bind] AirportViewModel airportView)
{
try
{
airportService.Edit(airportView.Id, airportView.Name, airportView.Address, airportView.Country);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex);
}
return(View(airportView));
}
public async Task <ActionResult <AirportViewModel> > Post(AirportViewModel airport)
{
var response = await _airportService.Create(airport.ToModel());
if (response != BusinessLogic.Enums.StatusCode.Created)
{
_logger.LogError($"Airport {airport.Name} not Created.");
}
return(response == BusinessLogic.Enums.StatusCode.Created
? (ActionResult <AirportViewModel>)Ok()
: Conflict());
}
//GET : /Airport/EDIT
public IActionResult Edit(Guid id)
{
Airport airport = airportManager.GetAirport(id);
AirportViewModel airportViewModel = new AirportViewModel()
{
AirportId = airport.AirportId,
Name = airport.Name,
Latitude = airport.Latitude,
Longitude = airport.Longitude
};
return(View(airportViewModel));
}
public static void FilteringAirportByCountry(IEnumerable ItemsSource, string country)
{
// Enable the filtering on Category
ListCollectionView empView = CollectionViewSource.GetDefaultView(ItemsSource) as ListCollectionView;
empView.IsLiveFiltering = true;
empView.LiveFilteringProperties.Add("Country");
empView.Filter = (item) =>
{
AirportViewModel airport = item as AirportViewModel;
return((airport != null) && airport.Country == country);
};
empView.Refresh();
}
// GET: Airports/Delete/5
public ActionResult AirportDelete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AirportViewModel airport = Mapper.Map <Airport, AirportViewModel>(_airportService.GetAirport((int)id));
if (airport == null)
{
return(HttpNotFound());
}
return(PartialView(airport));
}
public ActionResult Create(AirportViewModel airport)
{
//Can be only 3 symbols - to change it in the VIEW
if (ModelState.IsValid)
{
airportManager.AddAirport(airport.AirportName);
//unitOfWork.AirportRepository.AddAirport(airport.AirportName);
//unitOfWork.Save();
TempData["Message"] = this.airportManager.Message;
return(RedirectToAction("Create", "Airport"));
}
return(View(airport));
}
public async Task <IActionResult> Create(AirportViewModel model)
{
//TODO: use automapper and remove this code from here
var newAiroport = new Airport
{
Name = model.Name,
Latitude = model.Latitude,
Longitude = model.Longitude
};
_unitOfWork.AirportRepository.Add(newAiroport);
await _unitOfWork.SaveAsync();
return(RedirectToAction("Index"));
}
public ActionResult Edit(int id)
{
try
{
AirportDTO airportDTO = airportService.Get(id);
AirportViewModel airportView = new AirportViewModel {
Id = airportDTO.Id, Name = airportDTO.Name,
Address = airportDTO.Address, Country = airportDTO.Country
};
return(View(airportView));
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex);
}
return(RedirectToAction("Index"));
}
public void ReturnExpectedJson()
{
// Arrange
var cityService = new Mock <ICityService>();
var mappingService = new Mock <IMappingService>();
var airportService = new Mock <IAirportService>();
var testController = new TestController(mappingService.Object, cityService.Object, airportService.Object);
int id = 1;
string name = "Name";
var airportViewModel = new AirportViewModel()
{
Id = id,
Name = name
};
mappingService.Setup(m => m.Map <AirportViewModel>(It.IsAny <Airport>())).Returns(airportViewModel);
var airports = new List <Airport>()
{
new Airport(),
new Airport(),
new Airport(),
new Airport(),
};
airportService.Setup(c => c.GetAllAirportsInCity(It.IsAny <int>())).Returns(airports);
// Act ans Assert
// Act & Assert
var json = testController
.WithCallTo(h => h.LoadAirports(It.IsAny <int>()))
.ShouldReturnJson(data =>
{
var resultData = (IEnumerable <SelectListItem>)data;
Assert.AreEqual(4, resultData.Count());
foreach (var item in resultData)
{
Assert.AreEqual(item.Value, id.ToString());
Assert.AreEqual(item.Text, name);
}
});
}
public ActionResult List()
{
var airports = Airports;
if (airports == null)
{
airports = _airportService.GetAirportListInEU();
HttpContext.Response.Headers.Add("from-feed", "true");
Airports = airports;
}
var countries = airports?.GroupBy(f => f.iso).Select(f => f.Key).OrderBy(f => f).ToList();
var model = new AirportViewModel {
Airports = airports, Countries = countries
};
return(View(model));
}
public async Task <Response <string> > UpdateAirportAsync(int id, AirportViewModel model)
{
var airport = await _context.Airports.FindAsync(id);
if (airport == null)
{
return(new Response <string>
{
Success = false,
Message = "There is no such airport"
});
}
_mapper.Map(model, airport);
await _context.SaveChangesAsync();
return(new Response <string>
{
Success = true,
Message = "Airport was succesfully updated"
});
}
public void RedirectToIndexActionWhenModelStateIsInvalid()
{
// Arrange
var countryService = new Mock <ICountryService>();
var airlineService = new Mock <IAirlineService>();
var flightService = new Mock <IFlightService>();
var mappingService = new Mock <IMappingService>();
var cityService = new Mock <ICityService>();
var airportService = new Mock <IAirportService>();
var jobService = new Mock <IJobService>();
var adminController = new AdminController(countryService.Object, mappingService.Object, cityService.Object, airlineService.Object, airportService.Object, flightService.Object, jobService.Object);
adminController.ModelState.AddModelError(string.Empty, new Exception());
var expectedAirportVIewModel = new AirportViewModel()
{
Id = 1
};
// Act and Assert
adminController.WithCallTo(a => a.AddAirport(expectedAirportVIewModel))
.ShouldRedirectTo(typeof(AdminController).GetMethod("Index"));
}
public AirportView()
{
DataContext = new AirportViewModel();
InitializeComponent();
}
