private static async Task <FeatureViewModel> GetFullAndPartialViewModelForFeature(IDataContext context,
FeatureFilter filter)
{
var model = new FeatureViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings
};
var feature = await context.Vehicle.GetFdpFeature(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = feature.ProgrammeId,
Gateway = feature.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
if (!(feature is EmptyFdpFeature))
{
feature.Programme = model.Programmes.FirstOrDefault(p => p.Id == feature.ProgrammeId.GetValueOrDefault());
}
model.Feature = feature;
return(model);
}
private static IEnumerable <FdpModel> ListAvailableModelsFilteredByMarket(IDataContext context, Volume forVolume)
{
IEnumerable <FdpModel> filteredModels = Enumerable.Empty <FdpModel>();
if (forVolume.Document is EmptyOxoDocument || forVolume.Vehicle is EmptyVehicle)
{
return(filteredModels);
}
var filter = new ProgrammeFilter()
{
ProgrammeId = forVolume.Document.ProgrammeId,
Gateway = forVolume.Document.Gateway,
OxoDocId = forVolume.Document.Id
};
if (!(forVolume.Market is EmptyMarket))
{
filteredModels = context.Market.ListAvailableModelsByMarket(filter, forVolume.Market).Where(m => m.Available == true);
}
else if (!(forVolume.MarketGroup is EmptyMarketGroup))
{
filteredModels = context.Market.ListAvailableModelsByMarketGroup(filter, forVolume.MarketGroup).Where(m => m.Available == true);
}
else
{
filteredModels = forVolume.Vehicle.AvailableModels;
}
return(filteredModels);
}
private static async Task <ImportViewModel> GetFullAndPartialViewModelForImportQueueItem(IDataContext context,
ImportQueueFilter filter)
{
var model = new ImportViewModel(GetBaseModel(context))
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentImport = await context.Import.GetImportQueue(filter),
AvailableExceptionTypes = await context.Import.ListExceptionTypes(filter)
};
var programmeFilter = new ProgrammeFilter(model.CurrentImport.ProgrammeId)
{
DocumentId = model.CurrentImport.DocumentId
};
model.AvailableDocuments = context.Vehicle.ListPublishedDocuments(programmeFilter);
model.Exceptions = await context.Import.ListExceptions(filter);
model.TotalPages = model.Exceptions.TotalPages;
model.TotalRecords = model.Exceptions.TotalRecords;
model.TotalDisplayRecords = model.Exceptions.TotalDisplayRecords;
model.Document = model.AvailableDocuments.FirstOrDefault(d => d.Id == programmeFilter.DocumentId);
model.Programme = context.Vehicle.GetProgramme(programmeFilter);
model.Gateway = model.CurrentImport.Gateway;
model.Summary = await context.Import.GetImportSummary(filter);
return(model);
}
private static async Task <FeatureViewModel> GetFullAndPartialViewModelForFeatures(IDataContext context,
FeatureFilter filter)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new FeatureViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Features = await context.Vehicle.ListFdpFeatures(filter);
model.TotalPages = model.Features.TotalPages;
model.TotalRecords = model.Features.TotalRecords;
model.TotalDisplayRecords = model.Features.TotalDisplayRecords;
foreach (var feature in model.Features.CurrentPage)
{
feature.Programme = model.Programmes.FirstOrDefault(p => p.Id == feature.ProgrammeId.GetValueOrDefault());
}
return(model);
}
private static DerivativeViewModel GetFullAndPartialViewModelForOxoDerivatives(IDataContext context,
DerivativeFilter filter)
{
var baseModel = GetBaseModel(context);
var model = new DerivativeViewModel()
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.OxoDerivatives = context.Vehicle.ListDerivatives(filter);
return(model);
}
private static async Task <DerivativeViewModel> GetFullAndPartialViewModelForDerivative(IDataContext context,
DerivativeFilter filter)
{
var model = new DerivativeViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings
};
var derivative = await context.Vehicle.GetFdpDerivative(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = derivative.ProgrammeId,
Gateway = derivative.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
if (!(derivative is EmptyFdpDerivative))
{
derivative.Programme = model.Programmes.FirstOrDefault(p => p.Id == derivative.ProgrammeId.GetValueOrDefault());
derivative.Body = model.Bodies.FirstOrDefault(b => b.Id == derivative.BodyId);
derivative.Engine = model.Engines.FirstOrDefault(e => e.Id == derivative.EngineId);
derivative.Transmission = model.Transmissions.FirstOrDefault(t => t.Id == derivative.TransmissionId);
}
model.Derivative = derivative;
return(model);
}
private static async Task <TrimViewModel> GetFullAndPartialViewModelForTrim(IDataContext context,
TrimFilter filter)
{
var model = new TrimViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings
};
var trim = await context.Vehicle.GetFdpTrim(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = trim.ProgrammeId,
Gateway = trim.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
if (!(trim is EmptyFdpTrim))
{
trim.Programme = model.Programmes.FirstOrDefault(p => p.Id == trim.ProgrammeId);
}
model.Trim = trim;
return(model);
}
private static async Task <MarketMappingViewModel> GetFullAndPartialViewModelForMarketMapping
(
IDataContext context,
MarketMappingFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new MarketMappingViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var marketMapping = await context.Market.GetFdpMarketMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = marketMapping.ProgrammeId,
Gateway = marketMapping.Gateway,
Code = model.MarketMapping.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
if (!(marketMapping is EmptyFdpMarketMapping))
{
marketMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == marketMapping.ProgrammeId.GetValueOrDefault());
}
model.MarketMapping = marketMapping;
return(model);
}
public async Task <IEnumerable <FdpModel> > ListAvailableModels(ProgrammeFilter filter)
{
var models = await Task.FromResult(_modelDataStore
.ModelGetMany(filter)
.ToList());
return(models);
}
public async Task <ActionResult> ListAvailableMarkets(ProgrammeFilter filter)
{
MarketViewModel marketModel = new MarketViewModel();
marketModel.AvailableMarkets = await DataContext.Market.ListAvailableMarkets();
return(Json(marketModel));
}
public async Task <IVehicle> GetVehicle(ProgrammeFilter filter)
{
var vehicleFilter = new VehicleFilter()
{
ProgrammeId = filter.ProgrammeId,
Code = filter.Code
};
return(await GetVehicle(vehicleFilter));
}
public IEnumerable <FeatureGroup> ListFeatureGroups(ProgrammeFilter filter)
{
var groups = _featureDataStore.FeatureGroupGetMany().ToList();
groups.Add(new FeatureGroup()
{
FeatureGroupName = "OPTION PACKS"
});
return(groups);
}
public Programme GetProgramme(ProgrammeFilter filter)
{
var programmes = ListProgrammes(filter);
if (!programmes.Any())
{
return(new EmptyProgramme());
}
return(programmes.First());
}
public IEnumerable <TrimLevel> ListTrimLevels(ProgrammeFilter programmeFilter)
{
for (var i = 1; i <= 10; i++)
{
yield return(new TrimLevel()
{
Level = i,
DisplayOrder = i,
Description = string.Format("TL{0}", i)
});
}
}
private static async Task <DerivativeMappingViewModel> GetFullAndPartialViewModelForBrochureModelCodes
(
IDataContext context,
DerivativeMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new DerivativeMappingViewModel(baseModel)
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
filter.IncludeAllDerivatives = false;
model.OxoDerivatives = await context.Vehicle.ListOxoDerivatives(filter);
model.TotalPages = model.OxoDerivatives.TotalPages;
model.TotalRecords = model.OxoDerivatives.TotalRecords;
model.TotalDisplayRecords = model.OxoDerivatives.TotalDisplayRecords;
foreach (var oxoDerivative in model.OxoDerivatives.CurrentPage)
{
oxoDerivative.Document = model.Documents
.FirstOrDefault(d => d.Id == oxoDerivative.DocumentId);
oxoDerivative.Programme = model.Programmes
.FirstOrDefault(p => p.Id == oxoDerivative.ProgrammeId.GetValueOrDefault());
oxoDerivative.Body = model.Bodies
.FirstOrDefault(b => b.DocumentId == oxoDerivative.DocumentId && b.Id == oxoDerivative.BodyId);
oxoDerivative.Engine = model.Engines
.FirstOrDefault(e => e.DocumentId == oxoDerivative.DocumentId && e.Id == oxoDerivative.EngineId);
oxoDerivative.Transmission = model.Transmissions
.FirstOrDefault(t => t.DocumentId == oxoDerivative.DocumentId && t.Id == oxoDerivative.TransmissionId);
}
return(model);
}
private static async Task <DerivativeMappingViewModel> GetFullAndPartialViewModelForDerivativeMapping
(
IDataContext context,
DerivativeMappingFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new DerivativeMappingViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var derivativeMapping = await context.Vehicle.GetFdpDerivativeMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = derivativeMapping.ProgrammeId,
Gateway = derivativeMapping.Gateway,
Code = model.DerivativeMapping.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
// If we are copying to another gateway, we need to remove the source gateway from the list of available gateways
if (filter.Action == DerivativeMappingAction.Copy)
{
model.Gateways = model.Gateways.Where(g => !(g.Name.Equals(derivativeMapping.Gateway, StringComparison.InvariantCultureIgnoreCase)));
}
if (!(derivativeMapping is EmptyFdpDerivativeMapping))
{
derivativeMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == derivativeMapping.ProgrammeId.GetValueOrDefault());
derivativeMapping.Body = model.Bodies.FirstOrDefault(b => b.Id == derivativeMapping.BodyId);
derivativeMapping.Engine = model.Engines.FirstOrDefault(e => e.Id == derivativeMapping.EngineId);
derivativeMapping.Transmission = model.Transmissions.FirstOrDefault(t => t.Id == derivativeMapping.TransmissionId);
}
model.DerivativeMapping = derivativeMapping;
return(model);
}
private static async Task <TrimMappingViewModel> GetFullAndPartialViewModelForDPCKCodes
(
IDataContext context,
TrimMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new TrimMappingViewModel(baseModel)
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
filter.IncludeAllTrim = false;
filter.IgnoreBMC = true;
model.OxoTrim = await context.Vehicle.ListOxoTrim(filter);
model.TotalPages = model.OxoTrim.TotalPages;
model.TotalRecords = model.OxoTrim.TotalRecords;
model.TotalDisplayRecords = model.OxoTrim.TotalDisplayRecords;
foreach (var oxoTrim in model.OxoTrim.CurrentPage)
{
oxoTrim.Document = model.Documents
.FirstOrDefault(d => d.Id == oxoTrim.DocumentId);
oxoTrim.Programme = model.Programmes
.FirstOrDefault(p => p.Id == oxoTrim.ProgrammeId);
}
return(model);
}
public IEnumerable <Programme> ListProgrammes(ProgrammeFilter filter)
{
var programmes = _programmeDataStore.ProgrammeByGatewayGetMany();
if (programmes == null || !programmes.Any())
{
return(Enumerable.Empty <Programme>());
}
programmes = programmes
.Where(p => !filter.ProgrammeId.HasValue || p.Id == filter.ProgrammeId.Value)
.Where(p => !filter.VehicleId.HasValue || p.VehicleId == filter.VehicleId.Value)
.Where(p => string.IsNullOrEmpty(filter.Code) || p.VehicleName.Equals(filter.Code, StringComparison.InvariantCultureIgnoreCase))
.Where(p => string.IsNullOrEmpty(filter.Make) || p.VehicleMake.Equals(filter.Make, StringComparison.InvariantCultureIgnoreCase))
.Where(p => string.IsNullOrEmpty(filter.ModelYear) || p.ModelYear.Equals(filter.ModelYear, StringComparison.InvariantCultureIgnoreCase))
.Where(p => string.IsNullOrEmpty(filter.Gateway) || p.Gateway.Equals(filter.Gateway, StringComparison.InvariantCultureIgnoreCase))
.Select(p => p);
return(programmes);
}
private static async Task <SpecialFeatureMappingViewModel> GetFullAndPartialViewModelForFeatureMapping
(
IDataContext context,
SpecialFeatureMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new SpecialFeatureMappingViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var featureMapping = await context.Vehicle.GetFdpSpecialFeatureMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = featureMapping.ProgrammeId,
Gateway = featureMapping.Gateway,
Code = model.SpecialFeatureMapping.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
// If we are copying to another gateway, we need to remove the source gateway from the list of available gateways
if (filter.Action == SpecialFeatureMappingAction.Copy)
{
model.Gateways = model.Gateways.Where(g => !(g.Name.Equals(featureMapping.Gateway, StringComparison.InvariantCultureIgnoreCase)));
}
if (!(featureMapping is EmptyFdpSpecialFeatureMapping))
{
featureMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == featureMapping.ProgrammeId.GetValueOrDefault());
}
model.SpecialFeatureMapping = featureMapping;
return(model);
}
public IEnumerable<ModelEngine> ModelEngineGetMany(ProgrammeFilter filter)
{
IEnumerable<ModelEngine> retVal;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
retVal = conn.Query<ModelEngine>("dbo.Fdp_ModelEngine_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public IEnumerable <OXODoc> FdpOxoDocumentsGetMany(ProgrammeFilter filter)
{
IEnumerable <OXODoc> retVal = Enumerable.Empty <OXODoc>();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
para.Add("@Gateway", filter.Gateway, DbType.String);
retVal = conn.Query <OXODoc>("dbo.Fdp_OXODoc_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
private static async Task <IgnoredExceptionViewModel> GetFullAndPartialViewModelForIgnoredExceptions
(
IDataContext context,
IgnoredExceptionFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new IgnoredExceptionViewModel(baseModel)
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.IgnoredExceptions = await context.Import.ListFdpIgnoredExceptions(filter);
model.TotalPages = model.IgnoredExceptions.TotalPages;
model.TotalRecords = model.IgnoredExceptions.TotalRecords;
model.TotalDisplayRecords = model.IgnoredExceptions.TotalDisplayRecords;
foreach (var ignoredException in model.IgnoredExceptions.CurrentPage)
{
ignoredException.Programme = model.Programmes.FirstOrDefault(p => p.Id == ignoredException.ProgrammeId.GetValueOrDefault());
ignoredException.Document =
model.Documents.FirstOrDefault(d => d.Id == ignoredException.DocumentId.GetValueOrDefault());
}
return(model);
}
public IEnumerable <FdpModel> FdpModelsByMarketGroupGetMany(ProgrammeFilter filter)
{
IEnumerable <FdpModel> retVal = null;
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
para.Add("@MarketGroupId", filter.MarketGroupId, DbType.Int32);
retVal = conn.Query <FdpModel>("dbo.Fdp_AvailableModelByMarketGroup_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public IEnumerable <FdpSpecialFeature> FdpSpecialFeatureGetMany(ProgrammeFilter filter)
{
IEnumerable <FdpSpecialFeature> retVal = Enumerable.Empty <FdpSpecialFeature>();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
para.Add("@Gateway", filter.Gateway, DbType.String);
retVal = conn.Query <FdpSpecialFeature>("dbo.Fdp_SpecialFeatureMapping_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
private static async Task <IgnoredExceptionViewModel> GetFullAndPartialViewModelForIgnoredException
(
IDataContext context,
IgnoredExceptionFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new IgnoredExceptionViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var ignoredException = await context.Import.GetFdpImportErrorExclusion(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = ignoredException.ProgrammeId,
Gateway = ignoredException.Gateway,
Code = model.IgnoredException.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
if (!(ignoredException is EmptyFdpImportErrorExclusion))
{
ignoredException.Programme = model.Programmes.FirstOrDefault(p => p.Id == ignoredException.ProgrammeId.GetValueOrDefault());
ignoredException.Document =
model.Documents.FirstOrDefault(d => d.Id == ignoredException.DocumentId.GetValueOrDefault());
}
model.IgnoredException = ignoredException;
return(model);
}
private static async Task <DerivativeViewModel> GetFullAndPartialViewModelForDerivatives(IDataContext context,
DerivativeFilter filter)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new DerivativeViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Derivatives = await context.Vehicle.ListFdpDerivatives(filter);
model.TotalPages = model.Derivatives.TotalPages;
model.TotalRecords = model.Derivatives.TotalRecords;
model.TotalDisplayRecords = model.Derivatives.TotalDisplayRecords;
foreach (var derivative in model.Derivatives.CurrentPage)
{
derivative.Programme = model.Programmes.FirstOrDefault(p => p.Id == derivative.ProgrammeId.GetValueOrDefault());
derivative.Body = model.Bodies.FirstOrDefault(b => b.Id == derivative.BodyId);
derivative.Engine = model.Engines.FirstOrDefault(e => e.Id == derivative.EngineId);
derivative.Transmission = model.Transmissions.FirstOrDefault(t => t.Id == derivative.TransmissionId);
}
return(model);
}
private static void HydrateModelWithCommonProperties(FeatureMappingViewModel model, IDataContext context, ProgrammeFilter programmeFilter)
{
model.Programmes = context.Vehicle.ListProgrammes(programmeFilter);
model.Gateways = model.Programmes.ListGateways();
model.CarLines = model.Programmes.ListCarLines();
model.ModelYears = model.Programmes.ListModelYears();
model.Documents = context.Vehicle.ListPublishedDocuments(programmeFilter);
}
public async Task <IEnumerable <SpecialFeature> > ListSpecialFeatures(ProgrammeFilter programmeFilter)
{
return(await Task.FromResult(_takeRateDataStore.FdpSpecialFeatureTypeGetMany()));
}
private static void HydrateModelWithCommonProperties(TrimViewModel model, IDataContext context, ProgrammeFilter programmeFilter)
{
model.Programmes = context.Vehicle.ListProgrammes(programmeFilter);
model.Gateways = model.Programmes.ListGateways();
model.CarLines = model.Programmes.ListCarLines();
model.ModelYears = model.Programmes.ListModelYears();
}
private static void HydrateModelWithCommonProperties(DerivativeViewModel model, IDataContext context, ProgrammeFilter programmeFilter)
{
model.Programmes = context.Vehicle.ListProgrammes(programmeFilter);
model.Bodies = context.Vehicle.ListBodies(programmeFilter);
model.Engines = context.Vehicle.ListEngines(programmeFilter);
model.Transmissions = context.Vehicle.ListTransmissions(programmeFilter);
model.Gateways = model.Programmes.ListGateways();
model.CarLines = model.Programmes.ListCarLines();
model.ModelYears = model.Programmes.ListModelYears();
}
