public static IQueryable <Vehicle> RestrictByAdditionalParameters(Dictionary <DictionaryParameter, string> parameters, MarsDBDataContext dataContext
, IQueryable <Vehicle> vehicleData)
{
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.ForeignVehiclePredicament))
{
vehicleData = VehicleFieldRestrictions.RestrictByPredicament(vehicleData, parameters);
}
if (parameters.ContainsKey(DictionaryParameter.LicencePlate) &&
!string.IsNullOrEmpty(parameters[DictionaryParameter.LicencePlate]))
{
vehicleData = vehicleData.Where(d => d.LicensePlate.Contains(parameters[DictionaryParameter.LicencePlate]));
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.ExcludeOverdue))
{
vehicleData = parameters[DictionaryParameter.ExcludeOverdue] == "1"
? vehicleData.Where(d => d.ExpectedDateTime.HasValue && d.ExpectedDateTime.Value.Date >= DateTime.Now.Date)
: vehicleData.Where(d => d.ExpectedDateTime.HasValue && d.ExpectedDateTime.Value.Date < DateTime.Now.Date);
}
if (parameters.ContainsKey(DictionaryParameter.Vin) && !string.IsNullOrEmpty(parameters[DictionaryParameter.Vin]))
{
vehicleData = vehicleData.Where(d => d.Vin.Contains(parameters[DictionaryParameter.Vin]));
}
if (parameters.ContainsKey(DictionaryParameter.UnitNumber) &&
!string.IsNullOrEmpty(parameters[DictionaryParameter.UnitNumber]))
{
vehicleData = vehicleData.Where(d => d.UnitNumber == int.Parse(parameters[DictionaryParameter.UnitNumber]));
}
if (parameters.ContainsKey(DictionaryParameter.DriverName) && !string.IsNullOrEmpty(parameters[DictionaryParameter.DriverName]))
{
vehicleData = vehicleData.Where(d => d.LastDriverName.Contains(parameters[DictionaryParameter.DriverName]));
}
if (parameters.ContainsKey(DictionaryParameter.Colour) && !string.IsNullOrEmpty(parameters[DictionaryParameter.Colour]))
{
vehicleData = vehicleData.Where(d => d.Colour == parameters[DictionaryParameter.Colour]);
}
if (parameters.ContainsKey(DictionaryParameter.ModelDescription) &&
!string.IsNullOrEmpty(parameters[DictionaryParameter.ModelDescription]))
{
vehicleData = vehicleData.Where(d => d.ModelDescription.Contains(parameters[DictionaryParameter.ModelDescription]));
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.OperationalStatuses))
{
var selectedOperStats = parameters[DictionaryParameter.OperationalStatuses].Split(',').Select(int.Parse);
vehicleData = vehicleData.Where(d => selectedOperStats.Contains(d.LastOperationalStatusId));
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.MovementTypes))
{
var selectedMovementTypes = parameters[DictionaryParameter.MovementTypes].Split(',').Select(int.Parse);
vehicleData = vehicleData.Where(d => selectedMovementTypes.Contains(d.LastMovementTypeId));
}
if (parameters.ContainsKey(DictionaryParameter.MinDaysNonRev) && parameters[DictionaryParameter.MinDaysNonRev] != string.Empty)
{
var minDays = int.Parse(parameters[DictionaryParameter.MinDaysNonRev]);
vehicleData = from vd in vehicleData
where vd.DaysSinceLastRevenueMovement >= minDays
select vd;
}
return(vehicleData);
}
public static IQueryable <Vehicle> GetVehicleQueryable(Dictionary <DictionaryParameter, string> parameters, MarsDBDataContext dataContext
, bool includeRev, bool includeNonRev)
{
var vehicles = dataContext.Vehicles.Select(d => d);
vehicles = VehicleRestriction.RestrictVehicleQueryable(dataContext, vehicles);
if (!(includeRev && includeNonRev))
{
if (!includeRev)
{
vehicles = vehicles.Where(d => d.IsNonRev);
}
if (!includeNonRev)
{
vehicles = vehicles.Where(d => !d.IsNonRev);
}
}
var defleetedVehicle = parameters.ContainsKey(DictionaryParameter.DefleetedVehicles)
? parameters[DictionaryParameter.DefleetedVehicles] : string.Empty;
var noReason = parameters.ContainsKey(DictionaryParameter.NoReason)
? parameters[DictionaryParameter.NoReason] : string.Empty;
if (defleetedVehicle == string.Empty)
{
vehicles = vehicles.Where(d => d.IsFleet);
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarGroup))
{
vehicles = VehicleFieldRestrictions.RestrictByCarGroup(vehicles,
parameters[DictionaryParameter.CarGroup], dataContext);
}
else if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarClass))
{
vehicles = VehicleFieldRestrictions.RestrictByCarClass(vehicles,
parameters[DictionaryParameter.CarClass], dataContext);
}
else if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarSegment))
{
vehicles = VehicleFieldRestrictions.RestrictByCarSegment(vehicles,
parameters[DictionaryParameter.CarSegment], dataContext);
}
else if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.OwningCountry))
{
vehicles = VehicleFieldRestrictions.RestrictByOwningCountry(vehicles,
parameters[DictionaryParameter.OwningCountry]);
}
var expectedLocationLogic = parameters.ContainsValueAndIsntEmpty(DictionaryParameter.ExpectedLocationLogic);
bool restrictByLocationCountry = true;
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Location))
{
vehicles = VehicleFieldRestrictions.RestrictByLocation(vehicles,
parameters[DictionaryParameter.Location], dataContext, expectedLocationLogic);
restrictByLocationCountry = false;
}
else
{
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationGroup))
{
vehicles = VehicleFieldRestrictions.RestrictByLocationGroup(vehicles,
parameters[DictionaryParameter.LocationGroup], dataContext, expectedLocationLogic);
restrictByLocationCountry = false;
}
else if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Pool))
{
vehicles = VehicleFieldRestrictions.RestrictByPool(vehicles,
parameters[DictionaryParameter.Pool], dataContext, expectedLocationLogic);
restrictByLocationCountry = false;
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Area))
{
vehicles = VehicleFieldRestrictions.RestrictByArea(vehicles,
parameters[DictionaryParameter.Area], dataContext, expectedLocationLogic);
restrictByLocationCountry = false;
}
else if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Region))
{
vehicles = VehicleFieldRestrictions.RestrictByRegion(vehicles,
parameters[DictionaryParameter.Region], dataContext, expectedLocationLogic);
restrictByLocationCountry = false;
}
}
if (restrictByLocationCountry && parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationCountry))
{
vehicles = VehicleFieldRestrictions.RestrictByLocationCountry(vehicles,
parameters[DictionaryParameter.LocationCountry], expectedLocationLogic);
}
if (noReason == "0")
{
var reasonsEntered = from per in dataContext.VehicleNonRevPeriodEntryRemarks
where per.VehicleNonRevPeriodEntry.VehicleNonRevPeriod.Active &&
per.ExpectedResolutionDate >= DateTime.Now.Date //
select per.VehicleNonRevPeriodEntry.VehicleNonRevPeriod.Vehicle;
vehicles = vehicles.Except(reasonsEntered.Distinct());
}
if (parameters.ContainsValueAndIsntEmpty(DictionaryParameter.FleetTypes))
{
var selectedFleetTypes = parameters[DictionaryParameter.FleetTypes].Split(',').Select(byte.Parse);
vehicles = vehicles.Where(d => selectedFleetTypes.Contains(d.VehicleFleetTypeId));
}
if (parameters.ContainsKey(DictionaryParameter.OwningArea))
{
if (parameters[DictionaryParameter.OwningArea] != string.Empty)
{
//var selectedOwningAreas = parameters[DictionaryParameter.OwningArea].Split(',').Select(d => d);
//vehicles = vehicles.Where(d => selectedOwningAreas.Contains(d.OwningArea));
vehicles = vehicles.Where(d => d.OwningArea == parameters[DictionaryParameter.OwningArea]);
}
}
return(vehicles);
}
