public virtual IEnumerable <ValidationResult> Execute(int userId, int vehicleId, ICreateFillupEntryCommand fillup)
{
var foundVehicle = _vehicleRepository.GetVehicle(userId, vehicleId);
if (foundVehicle == null)
{
yield return(new ValidationResult(Resources.VehicleNotFound));
}
else
{
var fillups = _fillupRepository.GetFillups(vehicleId);
if (!fillups.Any())
{
yield break;
}
var priorFillup = fillups.Where(f => f.Date < fillup.Date).FirstOrDefault();
if ((priorFillup != null) && (priorFillup.Odometer >= fillup.Odometer))
{
yield return(new ValidationResult(
"Odometer",
string.Format(CultureInfo.CurrentUICulture,
Resources.OdometerNotGreaterThanPrior,
priorFillup.Odometer)));
}
}
}
public virtual IEnumerable <ReminderModel> Execute(int userId)
{
// this results in a SELECT N+1 scenario
try
{
var vehicles = _vehicleRepository.GetVehicles(userId);
var reminders = (from vehicle in vehicles
let fillups = _fillupRepository.GetFillups(vehicle.VehicleId)
let stats = CalculateStatistics.Calculate(fillups)
let odometer = stats.Odometer
from reminder in _reminderRepository.GetRemindersForVehicle(vehicle.VehicleId)
select new { viewmodel = ToViewModel(reminder), odometer })
.ToList();
foreach (var item in reminders)
{
item.viewmodel.UpdateLastVehicleOdometer(item.odometer);
}
var overdueReminders = reminders
.Select(x => x.viewmodel)
.Where(f => !f.IsFulfilled && f.IsOverdue)
.OrderBy(f => f.DueDistance)
.ThenBy(f => f.DueDate)
.ToList();
return(overdueReminders.ToList());
}
catch (InvalidOperationException ex)
{
throw new UnauthorizedException(Resources.UnableToRetrieveOverdueReminders, ex);
}
}
public virtual VehicleModel Execute(int userId, int vehicleId)
{
Vehicle vehicle = _vehicleRepository.GetVehicle(userId, vehicleId);
if (vehicle == null)
{
return(null);
}
var fillups = _fillupRepository.GetFillups(vehicle.VehicleId).OrderBy(f => f.Odometer);
var statistics = CalculateStatistics.Calculate(fillups);
return(new VehicleModel(vehicle, statistics));
}
public virtual IEnumerable <VehicleModel> Execute(int userId)
{
IEnumerable <Vehicle> vehicleData = null;
vehicleData = _vehicleRepository.GetVehicles(userId);
var vehicles = from vehicle in vehicleData
let fillups = _fillupRepository.GetFillups(vehicle.VehicleId).OrderBy(f => f.Odometer)
let statistics = CalculateStatistics.Calculate(fillups, includeFirst: false)
orderby vehicle.SortOrder
select new VehicleModel(vehicle, statistics);
return(vehicles);
}
public virtual FleetStatistics Execute(int userId)
{
var vehicles = _vehicleRepository.GetVehicles(userId);
var stats = from vehicle in vehicles
let fillups = _fillupRepository.GetFillups(vehicle.VehicleId)
where fillups.Any()
let statistics = CalculateStatistics.Calculate(fillups, includeFirst: false)
select statistics;
// These statistic calculations are for illustrative purposes only.
// If you were to build this application for real, you probably want to calculate this
// data more accurately and cache the results.
return(new FleetStatistics(stats));
}
public virtual IEnumerable <FillupEntry> Execute(int vehicleId)
{
try
{
var fillups = _fillupRepository
.GetFillups(vehicleId)
.OrderBy(f => f.Date)
.ToList();
return(new ReadOnlyCollection <FillupEntry>(fillups));
}
catch (InvalidOperationException ex)
{
throw new BusinessServicesException(Resources.UnableToRetireveFillupsExceptionMessage, ex);
}
}
private void CalculateSeriesForVehicle(Vehicle vehicle, StatisticSeries series, DateTime?startDate, DateTime?endDate)
{
Debug.Assert(series != null);
DateTime startFilterDate = startDate ?? DateTime.MinValue;
DateTime endFilterDate = endDate ?? DateTime.UtcNow;
var fillUps = _fillupRepository.GetFillups(vehicle.VehicleId);
var fillupGroups = from fillUp in fillUps
where ((fillUp.Date >= startFilterDate) && (fillUp.Date <= endFilterDate))
group fillUp by new { Year = fillUp.Date.Year, Month = fillUp.Date.Month }
into g
orderby g.Key.Year, g.Key.Month
select g;
var firstFillUp = fillUps.OrderBy(x => x.Date).FirstOrDefault();
VehicleStatisticsModel statistics;
foreach (var fillupGroup in fillupGroups)
{
var includeFirstFillup = (fillupGroup.Key.Year != firstFillUp.Date.Year) ||
(fillupGroup.Key.Month != firstFillUp.Date.Month);
statistics = CalculateStatistics.Calculate(fillupGroup, includeFirstFillup);
Debug.Assert(firstFillUp != null);
var seriesEntry = new StatisticSeriesEntry
{
Id = vehicle.VehicleId,
Name = vehicle.Name,
Year = fillupGroup.Key.Year,
Month = fillupGroup.Key.Month,
AverageFuelEfficiency = Math.Round(statistics.AverageFuelEfficiency, 2),
TotalCost = Math.Round(statistics.TotalCost, 2),
TotalDistance = statistics.TotalDistance,
};
series.Entries.Add(seriesEntry);
}
}
public virtual IEnumerable <ValidationResult> Execute(int userId, ICreateReminderCommand reminder)
{
var foundVehicle = _vehicleRepository.GetVehicle(userId, reminder.VehicleId);
if (foundVehicle == null)
{
yield return(new ValidationResult(Resources.VehicleNotFound));
}
else
{
var fillups = _fillupRepository.GetFillups(reminder.VehicleId);
var stats = CalculateStatistics.Calculate(fillups);
var odometer = stats.Odometer;
if ((reminder.DueDistance.HasValue) && (reminder.DueDistance.Value <= odometer))
{
yield return(new ValidationResult(
"DueDistance",
string.Format(CultureInfo.CurrentUICulture, Resources.DueDistanceNotGreaterThanOdometer, odometer)));
}
}
}
private void AdjustSurroundingFillupEntries(FillupEntry newFillup)
{
if (newFillup == null)
{
throw new ArgumentNullException("newFillup");
}
var fillups = _fillupRepository.GetFillups(newFillup.VehicleId);
// Prior fillups are ordered descending so that FirstOrDefault() chooses the one closest to the new fillup.
// Secondary ordering is by entry ID ensure a consistent ordering/
var priorFillup = fillups
.OrderByDescending(f => f.Date).ThenByDescending(f => f.FillupEntryId)
.FirstOrDefault(f => (f.Date <= newFillup.Date) && (f.FillupEntryId != newFillup.FillupEntryId));
// Prior fillups are ordered ascending that FirstOrDefault() chooses the one closest to the new fillup.
// Secondary ordering is by entry ID ensure a consistent ordering.
var nextFillup = fillups
.OrderBy(f => f.Date).ThenBy(f => f.FillupEntryId)
.FirstOrDefault(f => (f.Date >= newFillup.Date) && (f.FillupEntryId != newFillup.FillupEntryId));
CalculateInterFillupStatistics(newFillup, priorFillup);
CalculateInterFillupStatistics(nextFillup, newFillup);
}
