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 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;
}
public async Task<IVehicle> GetVehicle(ProgrammeFilter filter)
{
var vehicleFilter = new VehicleFilter()
{
ProgrammeId = filter.ProgrammeId,
Code = filter.Code
};
return await GetVehicle(vehicleFilter);
}
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<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;
}
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<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;
}
public Programme GetProgramme(ProgrammeFilter filter)
{
var programmes = ListProgrammes(filter);
if (!programmes.Any())
return new EmptyProgramme();
return programmes.First();
}
public IEnumerable<FeatureGroup> ListFeatureGroups(ProgrammeFilter filter)
{
var groups = _featureDataStore.FeatureGroupGetMany().ToList();
groups.Add(new FeatureGroup() { FeatureGroupName = "OPTION PACKS" });
return groups;
}
public async Task<IEnumerable<Feature>> ListFeatures(ProgrammeFilter filter)
{
return await Task.FromResult(_featureDataStore.FeatureGetMany("fdp", paramId: filter.VehicleId.Value));
}
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;
}
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<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;
}
public async Task<IEnumerable<FdpModel>> ListAvailableModels(ProgrammeFilter filter)
{
var models = await Task.FromResult(_modelDataStore
.ModelGetMany(filter)
.ToList());
return models;
}
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<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 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();
}
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;
}
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 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 IEnumerable<ModelBody> ListBodies(ProgrammeFilter filter)
{
return _bodyDataStore.ModelBodyGetMany(filter);
}
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<ImportViewModel> GetFullAndPartialViewModelForException(IDataContext context,
ImportQueueFilter filter)
{
var model = new ImportViewModel(GetBaseModel(context))
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentException = await context.Import.GetException(filter)
};
var programmeFilter = new ProgrammeFilter(model.CurrentException.ProgrammeId) { DocumentId = model.CurrentException.DocumentId };
var featureFilter = new FeatureFilter { ProgrammeId = model.CurrentException.ProgrammeId, DocumentId = model.CurrentException.DocumentId };
model.Programme = context.Vehicle.GetProgramme(programmeFilter);
programmeFilter.VehicleId = model.Programme.VehicleId;
model.Gateway = model.CurrentException.Gateway;
model.AvailableDocuments = context.Vehicle.ListPublishedDocuments(programmeFilter);
model.AvailableEngines = context.Vehicle.ListEngines(programmeFilter);
model.AvailableTransmissions = context.Vehicle.ListTransmissions(programmeFilter);
model.AvailableBodies = context.Vehicle.ListBodies(programmeFilter);
model.AvailableSpecialFeatures = await context.TakeRate.ListSpecialFeatures(programmeFilter);
model.AvailableMarkets = await context.Market.ListAvailableMarkets();
model.AvailableFeatures = await context.Vehicle.ListFeatures(featureFilter);
model.AvailableFeatureGroups = context.Vehicle.ListFeatureGroups(programmeFilter);
model.AvailableTrimLevels = context.Vehicle.ListTrimLevels(programmeFilter);
var derivativeFilter = new DerivativeFilter
{
CarLine = model.Programme.VehicleName,
ModelYear = model.Programme.ModelYear,
Gateway = model.Gateway,
ProgrammeId = model.CurrentException.ProgrammeId,
};
model.AvailableDerivatives = context.Vehicle.ListDerivatives(derivativeFilter);
model.AvailableImportDerivatives = await ListImportDerivatives(model.CurrentException.ImportQueueId, context);
model.AvailableImportTrimLevels = await ListImportTrimLevels(model.CurrentException.ImportQueueId, context);
model.AvailableImportFeatures = await ListImportFeatures(model.CurrentException.ImportQueueId, context);
derivativeFilter.Bmc = model.CurrentException.ImportDerivativeCode;
var trimFilter = new TrimMappingFilter
{
CarLine = model.Programme.VehicleName,
ModelYear = model.Programme.ModelYear,
Gateway = model.Gateway,
DocumentId = model.CurrentException is EmptyOxoDocument ? (int?) null : model.CurrentException.DocumentId,
IncludeAllTrim = false
};
model.AvailableTrim = (await context.Vehicle.ListOxoTrim(trimFilter)).CurrentPage;
model.Document = model.AvailableDocuments.FirstOrDefault(d => d.Id == model.CurrentException.DocumentId);
return model;
}
public IEnumerable<Gateway> ListGateways(ProgrammeFilter filter)
{
return _documentDataStore.GatewayGetMany().Where(g => string.IsNullOrEmpty(filter.Code) || g.VehicleName == filter.Code);
}
private static async Task<FeatureMappingViewModel> GetFullAndPartialViewModelForFeatureCodes
(
IDataContext context,
FeatureMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new FeatureMappingViewModel(baseModel)
{
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 programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.OxoFeatures = await context.Vehicle.ListOxoFeatures(filter);
model.TotalPages = model.OxoFeatures.TotalPages;
model.TotalRecords = model.OxoFeatures.TotalRecords;
model.TotalDisplayRecords = model.OxoFeatures.TotalDisplayRecords;
foreach (var oxoFeature in model.OxoFeatures.CurrentPage)
{
oxoFeature.Programme = model.Programmes.FirstOrDefault(p => p.Id == oxoFeature.ProgrammeId.GetValueOrDefault());
oxoFeature.Document = oxoFeature.Document = model.Documents.FirstOrDefault(d => d.Id == oxoFeature.DocumentId);
}
return model;
}
public IEnumerable<OXODoc> ListPublishedDocuments(ProgrammeFilter filter)
{
return _documentDataStore.FdpOxoDocumentsGetMany(filter);
}
private static async Task<FeatureMappingViewModel> GetFullAndPartialViewModelForFeatureMapping
(
IDataContext context,
FeatureMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new FeatureMappingViewModel()
{
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.GetFdpFeatureMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = featureMapping.ProgrammeId,
Gateway = featureMapping.Gateway,
Code = model.FeatureMapping.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 == FeatureMappingAction.Copy)
{
model.Gateways = model.Gateways.Where(g => !(g.Name.Equals(featureMapping.Gateway, StringComparison.InvariantCultureIgnoreCase)));
}
if (!(featureMapping is EmptyFdpFeatureMapping))
{
featureMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == featureMapping.ProgrammeId.GetValueOrDefault());
}
model.FeatureMapping = featureMapping;
return model;
}
public IEnumerable<ModelTransmission> ListTransmissions(ProgrammeFilter filter)
{
return _transmissionDataStore.ModelTransmissionGetMany(filter);
}
public async Task<IEnumerable<SpecialFeature>> ListSpecialFeatures(ProgrammeFilter programmeFilter)
{
return await Task.FromResult(_takeRateDataStore.FdpSpecialFeatureTypeGetMany());
}
public IEnumerable<ModelEngine> ListEngines(ProgrammeFilter filter)
{
return _engineDataStore.ModelEngineGetMany(filter);
}
