/// <summary>
/// Get a list of all vehicles from the Star Wars API and present some summary information.
/// The top portion of the view will display the total number of vehicles where the cost is not "unknown",
/// as well as the total number of unique manufacturers.
/// For the table, take the vehicles where the cost is not "unknown", and group them by manufacturer.
/// For each group(table row), get the manufacturer name, the number of vehicles by that manufacturer,
/// and their average cost.
/// Sort them by vehicle count(highest to lowest), then by average cost(highest to lowest).
/// </summary>
/// <returns>ActionResult</returns>
public async Task <IActionResult> VehicleSummary()
{
var model = new VehicleSummaryViewModel();
var vehicles = await _StarWarsService.GetVehiclesAsync();
var vehiclesWithKnownCost = vehicles.Where(v => v.Cost != "unknown").ToList();
model.VehicleCount = vehiclesWithKnownCost.Count;
model.ManufacturerCount = vehicles.Select(v => v.Manufacturer).Distinct().Count();
model.Details = vehiclesWithKnownCost
.Select(v => new VehicleViewModel
{
Cost = v.Cost,
Manufacturer = v.Manufacturer
})
.GroupBy(v => v.Manufacturer)
.Select(g => new VehicleStatsViewModel
{
ManufacturerName = g.Key,
VehicleCount = g.Count(),
AverageCost = g.Average(v => v.CostAsDouble)
})
.OrderByDescending(s => s.VehicleCount)
.ThenByDescending(s => s.AverageCost)
.ToList();
return(View(model));
}
public VehicleSummaryViewModel ToVehicleSummaryViewModel()
{
var model = new VehicleSummaryViewModel();
model.VehicleCount = Results.Where(v => v.Cost != "unknown").Count();
var distinctModels = Results.Select(v => v.Manufacturer).Distinct().ToList();
model.ManufacturerCount = distinctModels.Count();
var allVehicleStats = new List <VehicleStatsViewModel>();
distinctModels.ForEach(m =>
{
var manufacturerVehicles = Results.Where(v => v.Cost != "unknown" && v.Manufacturer == m).ToList();
if (manufacturerVehicles.Count() > 0)
{
var vehicleStats = new VehicleStats();
vehicleStats.Manufacturer = m;
vehicleStats.Vehicles.AddRange(manufacturerVehicles);
allVehicleStats.Add(vehicleStats.ToVehicleStatsViewModel());
}
});
allVehicleStats = allVehicleStats.OrderByDescending(v => v.VehicleCount).ThenByDescending(v => v.AverageCost).ToList();
model.Details.AddRange(allVehicleStats);
return(model);
}
public async Task <ActionResult> VehicleSummary(CancellationToken cancellationToken)
{
// TODO: Implement this controller action
VehicleSummaryViewModel vm = null;
try
{
vm = await _starWarsService.VehicleSummaryAsync(cancellationToken);
}
catch (NullReferenceException ex)
{
if (ex.Message.Contains("not found"))
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
//potentially log error here and return 500
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
catch (Exception ex)
{
//potentially log error and rethrow error, or, in this case, just return 500
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
return(View(vm));
}
public async Task <ActionResult> VehicleSummary()
{
var model = new VehicleSummaryViewModel();
List <VehicleModel> vehicles = await starWarsApi.GetAllVehiclesAsync();
model.VehicleCount = vehicles.Where(x => x.VehicleCost != "unknown").Count();
model.ManufacturerCount = vehicles.GroupBy(x => x.VehicleManufacturer).Count();
//filter out vehicles where cost is unknown, order by manufacturer
List <VehicleSummaryModel> vehicleSummary = vehicles.Where(v => v.VehicleCost != "unknown")
.GroupBy(v => v.VehicleManufacturer)
.Select(s1 => new VehicleSummaryModel
{
ManufacturerName = s1.First().VehicleManufacturer,
NumberOfVehicles = s1.Count(),
AverageVehicleCost = s1.Average(x => Convert.ToDouble(x.VehicleCost)),
}).ToList();
vehicleSummary = vehicleSummary.OrderByDescending(x => x.NumberOfVehicles)
.ThenByDescending(x => x.AverageVehicleCost).ToList();
foreach (VehicleSummaryModel vsm in vehicleSummary)
{
VehicleStatsViewModel vsvm = new VehicleStatsViewModel();
vsvm.ManufacturerName = vsm.ManufacturerName;
vsvm.VehicleCount = vsm.NumberOfVehicles;
vsvm.AverageCost = vsm.AverageVehicleCost;
model.Details.Add(vsvm);
}
return(View(model));
}
public ActionResult VehicleSummary()
{
// TODO: Implement this controller action
List <Vehicle> vehicleList = _starWarsService.GetVehicles().Result;
VehicleSummaryViewModel model = _viewMapperHelper.VehiclesMapper(vehicleList);
return(View(model));
}
public ActionResult VehicleSummary()
{
var model = new VehicleSummaryViewModel();
// TODO: Implement this controller action
return(View(model));
}
private static VehicleSummaryViewModel CreateSummaryViewModel(ParkedVehicle vehicle)
{
var model = new VehicleSummaryViewModel();
var owner = vehicle.Member;
model.Colour = vehicle.Colour;
model.RegistrationNumber = vehicle.RegistrationNumber;
model.ParkingTime = DateTime.Now - vehicle.ParkingDate;
model.Type = vehicle.Type;
model.OwnerName = owner.FullName;
return(model);
}
private static VehicleSummaryViewModel CreateSummaryViewModel(ParkedVehicle vehicle, IEnumerable <Member> members)
{
var model = new VehicleSummaryViewModel();
var owner = members.FirstOrDefault(m => m.MemberId == vehicle.MemberId);
model.Colour = vehicle.Colour;
model.RegistrationNumber = vehicle.RegistrationNumber;
model.ParkingTime = DateTime.Now - vehicle.ParkingDate;
model.Type = vehicle.Type;
model.OwnerName = owner.FirstName + " " + owner.LastName;
return(model);
}
/// <summary>
/// Creates a summary view of all manufacturers vehicles
/// </summary>
/// <returns>View of all the vehicles</returns>
public VehicleSummaryViewModel GetAllVehicles()
{
// Create our vehicle Summary
var vehicleSummary = new VehicleSummaryViewModel();
// Get our list of vehicles
var vehicles = vehiclesAPI.GetAllVehicles();
// Get the total number of vehicles where the cost is unknnown
vehicleSummary.VehicleCount = vehicles.Vehicles
.Where(vehicle => vehicle.Cost_in_credits == "unknown")
.Count();
// Group the known cost models by manufacturer
var vehiclesByManufacturer = vehicles.Vehicles
.Where(vehicle => vehicle.Cost_in_credits != "unknown")
.GroupBy(vehicle => vehicle.manufacturer).ToList();
// Get the number of Manufacturers
vehicleSummary.ManufacturerCount = vehiclesByManufacturer.Count();
// Add each manufacturers vehicle summary to the view
vehiclesByManufacturer.ToList().ForEach(manufacturer =>
{
// Create a new model for each manufacturer
var vehicleStatsSummary = new VehicleStatsViewModel();
// Set the manufacturer name
vehicleStatsSummary.ManufacturerName = manufacturer.Key;
// Set the number of vehicles
vehicleStatsSummary.VehicleCount = manufacturer.Count();
// Get the vehicles that the cost is known
var vehiclesWithCost = manufacturer;
// Set the average cost
vehicleStatsSummary.AverageCost = vehiclesWithCost.Average(vehicle => long.Parse(vehicle.Cost_in_credits));
// Add the manufacturer summary
vehicleSummary.Details.Add(vehicleStatsSummary);
});
// Sort the results
vehicleSummary.Details = vehicleSummary.Details
.OrderByDescending(manufacturer => manufacturer.VehicleCount)
.ThenByDescending(manufacturer => manufacturer.AverageCost)
.ToList();
return(vehicleSummary);
}
public VehicleSummaryViewModel VehiclesMapper(List <Vehicle> vehicles)
{
var model = new VehicleSummaryViewModel();
model.VehicleCount = 0;
int mfrCount = 0;
foreach (Vehicle veh in vehicles)
{
if (veh.CostInCredits != "unknown")
{
//manufacturer doesn't exist yet
if (!model.Details.Any(v => v.ManufacturerName == veh.Manufacturer))
{
List <Vehicle> mfrVehicles = vehicles.Where(v => v.Manufacturer == veh.Manufacturer).ToList();
//vStats.VehicleCount = mfrVehicles.Count;
//List<Vehicle> costVehicles = mfrVehicles.Where(v => (Int32.TryParse(v.CostInCredits, out int cost))).ToList();
List <Vehicle> costVehicles = mfrVehicles.Where(v => v.CostInCredits != "unknown").ToList();
if (costVehicles.Count > 0)
{
VehicleStatsViewModel vStats = new VehicleStatsViewModel
{
ManufacturerName = veh.Manufacturer,
AverageCost = costVehicles.Average(v => Convert.ToInt32(v.CostInCredits)),
VehicleCount = costVehicles.Count
};
var config = new MapperConfiguration(cfg =>
cfg.CreateMap <Vehicle, VehicleDetailViewModel>()
);
var mapper = config.CreateMapper();
vStats.Vehicles = mapper.Map <List <VehicleDetailViewModel> >(costVehicles);
//aveCost = costVehicles.Average(v => Convert.ToInt32(v.CostInCredits));
model.VehicleCount += costVehicles.Count;
model.Details.Add(vStats);
//vStats.AverageCost = vehicles.Where(v => !string.IsNullOrEmpty(v.CostInCredits) && v.CostInCredits.All(Char.IsDigit)).Convert.ToIntAverage(v => v.);
mfrCount++;
}
}
}
}
model.ManufacturerCount = mfrCount;
model.Details = model.Details.OrderByDescending(v => v.VehicleCount).ThenByDescending(a => a.AverageCost).ToList();
return(model);
}
public VehicleSummaryViewModel GetVehiclesSummary()
{
VehicleSummaryViewModel vehiclesSummary = new VehicleSummaryViewModel();
List <VehicleModel> vehicles = swapiAccessors.RequestAllVehicles();
List <VehicleModel> vehiclesWithCost = vehicles.Where(v => v.Cost != "unknown").ToList();
var query = vehiclesWithCost
.GroupBy(v => v.Manufacturer,
(man) => new VehicleStatsViewModel()
{
ManufacturerName = man.Manufacturer,
VehicleCount = vehiclesWithCost.Where(count => count.Manufacturer == man.Manufacturer).Count(),
AverageCost =
vehiclesWithCost
.Where(c => (c.Manufacturer == man.Manufacturer))
.Average(a => Convert.ToDouble(a.Cost))
});
vehiclesSummary.Details.AddRange(query.Where(m => !m.Key.Equals("Unknown")).Select(k => k.First <VehicleStatsViewModel>()).ToList().OrderByDescending(x => x.VehicleCount).ThenByDescending(y => y.AverageCost));
vehiclesSummary.ManufacturerCount = vehiclesSummary.Details.Count();
vehiclesSummary.VehicleCount = vehicles.Where(c => c.Cost != "unknown").Count();
return(vehiclesSummary);
}
public async Task <IActionResult> Index(string RegNum, int?type, string sortOrder)
{
ViewBag.TypeSortParm = String.IsNullOrEmpty(sortOrder) ? "type_desc" : "";
ViewBag.RegistrationNumberSortParm = sortOrder == "RegistrationNumber" ? "RegistrationNumber_desc" : "RegistrationNumber";
ViewBag.ColourSortParm = sortOrder == "Colour" ? "Colour_desc" : "Colour";
ViewBag.ParkingTimeSortParm = sortOrder == "ParkingTime" ? "ParkingTime_desc" : "ParkingTime";
ViewBag.OwnerNameSortParm = sortOrder == "OwnerName" ? "OwnerName_desc" : "OwnerName";
var vehicles = string.IsNullOrWhiteSpace(RegNum) ?
_context.ParkedVehicles.Include(v => v.Member) :
_context.ParkedVehicles.Include(v => v.Member).Where(m => m.RegistrationNumber.Contains(RegNum));
IEnumerable <SelectListItem> vehicleTypeSelectItems = await GetVehicleTypeSelectListItems();
vehicles = type == null ?
vehicles :
vehicles.Where(m => m.VehicleTypeId == type);
var viewModels = new List <VehicleSummaryViewModel>();
IEnumerable <Member> members = _context.Members;
foreach (ParkedVehicle vehicle in vehicles)
{
if (vehicle.IsParked)
{
VehicleSummaryViewModel viewModel = CreateSummaryViewModel(vehicle);
viewModels.Add(viewModel);
}
}
switch (sortOrder)
{
case "type_desc":
viewModels = viewModels.OrderByDescending(s => s.Type).ToList();
break;
case "RegistrationNumber":
viewModels = viewModels.OrderBy(s => s.RegistrationNumber).ToList();
break;
case "RegistrationNumber_desc":
viewModels = viewModels.OrderByDescending(s => s.RegistrationNumber).ToList();
break;
case "ParkingTime":
viewModels = viewModels.OrderBy(s => s.ParkingTime).ToList();
break;
case "ParkingTime_desc":
viewModels = viewModels.OrderByDescending(s => s.ParkingTime).ToList();
break;
case "Colour":
viewModels = viewModels.OrderBy(s => s.Colour).ToList();
break;
case "Colour_desc":
viewModels = viewModels.OrderByDescending(s => s.Colour).ToList();
break;
case "OwnerName":
viewModels = viewModels.OrderBy(s => s.OwnerName).ToList();
break;
case "OwnerName_desc":
viewModels = viewModels.OrderByDescending(s => s.OwnerName).ToList();
break;
default:
viewModels = viewModels.OrderBy(s => s.Type).ToList();
break;
}
return(View(new Tuple <IEnumerable <VehicleSummaryViewModel>, IEnumerable <SelectListItem> >
(viewModels, vehicleTypeSelectItems)));
}
public ActionResult VehicleSummary()
{
var model = new VehicleSummaryViewModel();
return(View(model));
}
