public BmcMapping GetMappedBmc(DerivativeFilter filter)
{
BmcMapping mapping = null;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
para.Add("@Gateway", filter.Gateway, DbType.String);
para.Add("@ImportBMC", filter.Bmc, DbType.String);
var results = conn.Query <BmcMapping>("Fdp_Derivative_GetMappedBMC", para, commandType: CommandType.StoredProcedure);
var bmcMappings = results as IList <BmcMapping> ?? results.ToList();
if (results != null && bmcMappings.Any())
{
mapping = bmcMappings.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(mapping);
}
public IEnumerable <Derivative> ListDerivatives(DerivativeFilter filter)
{
var derivatives = _derivativeDataStore.DerivativeGetMany(filter);
var listDerivatives = derivatives as IList <Derivative> ?? derivatives.ToList();
// Eliminate the derivatives with no BMC as this will cause real issues
if (derivatives != null && listDerivatives.Any())
{
listDerivatives = listDerivatives.Where(d => !string.IsNullOrEmpty(d.DerivativeCode)).ToList();
}
foreach (var derivative in listDerivatives)
{
if (derivative.BodyId.HasValue)
{
derivative.Body = _bodyDataStore.ModelBodyGet(derivative.BodyId.Value, filter.DocumentId);
}
if (derivative.EngineId.HasValue)
{
derivative.Engine = _engineDataStore.ModelEngineGet(derivative.EngineId.Value, filter.DocumentId);
}
if (derivative.TransmissionId.HasValue)
{
derivative.Transmission =
_transmissionDataStore.ModelTransmissionGet(derivative.TransmissionId.Value, filter.DocumentId);
}
}
return(listDerivatives);
}
public async Task <ActionResult> ListDerivatives(DerivativeParameters parameters)
{
ValidateDerivativeParameters(parameters, DerivativeParametersValidator.NoValidation);
var filter = new DerivativeFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = DerivativeAction.Derivatives
};
filter.InitialiseFromJson(parameters);
var results = await DerivativeViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.Derivatives.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <ActionResult> DerivativePage(DerivativeParameters parameters)
{
var filter = new DerivativeFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await DerivativeViewModel.GetModel(DataContext, filter)));
}
private static DerivativeViewModel GetFullAndPartialViewModel(IDataContext context,
DerivativeFilter filter)
{
var model = new DerivativeViewModel(GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return(model);
}
public async Task <ActionResult> ContextMenu(DerivativeParameters parameters)
{
ValidateDerivativeParameters(parameters, DerivativeParametersValidator.DerivativeIdentifier);
var filter = DerivativeFilter.FromParameters(parameters);
filter.Action = DerivativeAction.Derivative;
var derivativeView = await DerivativeViewModel.GetModel(DataContext, filter);
return(PartialView("_ContextMenu", derivativeView));
}
public IEnumerable <Derivative> DerivativeGetMany(DerivativeFilter filter)
{
filter.PageSize = 1000;
filter.IncludeAllDerivatives = true;
var derivatives = FdpDerivativeMappingGetMany(filter);
if (derivatives == null || derivatives.CurrentPage == null || !derivatives.CurrentPage.Any())
{
return(Enumerable.Empty <Derivative>());
}
return(derivatives.CurrentPage);
}
public FdpDerivative FdpDerivativeGet(DerivativeFilter filter)
{
FdpDerivative retVal = new EmptyFdpDerivative();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpDerivativeId", filter.DerivativeId.GetValueOrDefault(), DbType.Int32);
retVal = conn.Query <FdpDerivative>("dbo.Fdp_Derivative_Get", para, commandType: CommandType.StoredProcedure).FirstOrDefault();
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public static async Task <DerivativeViewModel> GetModel(IDataContext context, DerivativeFilter derivativeFilter)
{
DerivativeViewModel model = null;
if (derivativeFilter.Action == DerivativeAction.Delete || derivativeFilter.Action == DerivativeAction.Derivative)
{
model = await GetFullAndPartialViewModelForDerivative(context, derivativeFilter);
}
else if (derivativeFilter.Action == DerivativeAction.Derivatives)
{
model = await GetFullAndPartialViewModelForDerivatives(context, derivativeFilter);
}
else if (derivativeFilter.Action == DerivativeAction.OxoDerivatives)
{
model = GetFullAndPartialViewModelForOxoDerivatives(context, derivativeFilter);
}
else
{
model = GetFullAndPartialViewModel(context, derivativeFilter);
}
if (derivativeFilter.Action != DerivativeAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(derivativeFilter.Action.GetType(), derivativeFilter.Action);
}
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> 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 <BmcMapping> GetMappedBmc(DerivativeFilter filter)
{
return(await Task.FromResult(_derivativeDataStore.GetMappedBmc(filter)));
}
public async Task <PagedResults <FdpDerivative> > ListFdpDerivatives(DerivativeFilter filter)
{
return(await Task.FromResult(_derivativeDataStore.FdpDerivativeGetMany(filter)));
}
public async Task <FdpDerivative> GetFdpDerivative(DerivativeFilter filter)
{
return(await Task.FromResult(_derivativeDataStore.FdpDerivativeGet(filter)));
}
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);
}
public PagedResults <FdpDerivativeMapping> FdpDerivativeMappingGetMany(DerivativeFilter filter)
{
PagedResults <FdpDerivativeMapping> retVal = null;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
var totalRecords = 0;
var totalDisplayRecords = 0;
if (!string.IsNullOrEmpty(filter.CarLine))
{
para.Add("@CarLine", filter.CarLine, DbType.String);
}
if (!string.IsNullOrEmpty(filter.ModelYear))
{
para.Add("@ModelYear", filter.ModelYear, DbType.String);
}
if (!string.IsNullOrEmpty(filter.Gateway))
{
para.Add("@Gateway", filter.Gateway, DbType.String);
}
if (filter.PageIndex.HasValue)
{
para.Add("@PageIndex", filter.PageIndex.Value, DbType.Int32);
}
if (filter.PageSize.HasValue)
{
para.Add("@PageSize", filter.PageSize.Value, DbType.Int32);
}
if (filter.SortIndex.HasValue)
{
para.Add("@SortIndex", filter.SortIndex.Value, DbType.Int32);
}
if (filter.SortDirection != SortDirection.NotSet)
{
var direction = filter.SortDirection == SortDirection.Descending ? "DESC" : "ASC";
para.Add("@SortDirection", direction, DbType.String);
}
if (filter.IncludeAllDerivatives)
{
para.Add("@IncludeAllDerivatives", true, DbType.Boolean);
}
if (filter.OxoDerivativesOnly)
{
para.Add("@OxoDerivativesOnly", filter.OxoDerivativesOnly, DbType.Boolean);
}
para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
para.Add("@TotalPages", DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalRecords", DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalDisplayRecords", DbType.Int32, direction: ParameterDirection.Output);
var results = conn.Query <FdpDerivativeMapping>("dbo.Fdp_DerivativeMapping_GetMany", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
totalRecords = para.Get <int>("@TotalRecords");
totalDisplayRecords = para.Get <int>("@TotalDisplayRecords");
}
retVal = new PagedResults <FdpDerivativeMapping>
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
TotalRecords = totalRecords,
TotalDisplayRecords = totalDisplayRecords,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : totalRecords
};
var currentPage = new List <FdpDerivativeMapping>();
foreach (var result in results)
{
currentPage.Add(result);
}
retVal.CurrentPage = currentPage;
}
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);
}
