public async Task<ImportQueue> GetImportQueue(ImportQueueFilter filter)
{
if (!filter.ImportQueueId.HasValue)
throw new ArgumentNullException("ImportQueueId not specified");
return await Task.FromResult(_importDataStore.ImportQueueGet(filter.ImportQueueId.Value));
}
public async Task<PagedResults<ImportQueue>> ListImportQueue(ImportQueueFilter filter)
{
var results = await Task.FromResult(
_importDataStore.ImportQueueGetMany(filter));
return results;
}
public async Task<ActionResult> ListImportExceptions(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ImportQueueIdentifier);
var filter = new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault())
{
ExceptionType = parameters.ExceptionType,
FilterMessage = parameters.FilterMessage,
Action = ImportAction.ImportQueueItem
};
filter.InitialiseFromJson(parameters);
var results = await ImportViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
// Iterate through the results and put them in a format that can be used by jQuery datatables
if (!results.HasExceptions()) return Json(jQueryResult);
jQueryResult.TotalSuccess = results.Exceptions.TotalSuccess;
jQueryResult.TotalFail = results.Exceptions.TotalFail;
foreach (var result in results.Exceptions.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return Json(jQueryResult);
}
public async Task<ImportError> IgnoreException(ImportQueueFilter filter, bool reprocess)
{
return await Task.FromResult(_importDataStore.ImportExceptionIgnore(filter, reprocess));
}
public async Task<ImportError> IgnoreException(ImportQueueFilter filter)
{
return await IgnoreException(filter, true);
}
public IEnumerable<ImportExceptionType> ImportExceptionTypeGetMany(ImportQueueFilter filter)
{
var results = Enumerable.Empty<ImportExceptionType>();
using (IDbConnection connection = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpImportQueueId", filter.ImportQueueId.Value, DbType.Int32);
para.Add("@CDSId", CurrentCDSID, DbType.String);
results = connection.Query<ImportExceptionType>("dbo.Fdp_ImportErrorType_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return results;
}
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<ImportViewModel> GetFullAndPartialViewModelForImportQueue(IDataContext context,
ImportQueueFilter filter)
{
var model = new ImportViewModel(GetBaseModel(context))
{
PageIndex = filter.PageIndex ?? 1,
PageSize = filter.PageSize ?? int.MaxValue,
Configuration = context.ConfigurationSettings,
ImportQueue = await context.Import.ListImportQueue(filter)
};
model.TotalPages = model.ImportQueue.TotalPages;
model.TotalRecords = model.ImportQueue.TotalRecords;
model.TotalDisplayRecords = model.ImportQueue.TotalDisplayRecords;
model.AvailableProgrammes = context.Vehicle.ListProgrammes(new ProgrammeFilter());
model.AvailableDocuments = context.Vehicle.ListPublishedDocuments(new ProgrammeFilter());
return model;
}
public PagedResults<ImportQueue> ImportQueueGetMany(ImportQueueFilter filter)
{
PagedResults<ImportQueue> retVal = null;
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
var totalRecords = 0;
var totalDisplayRecords = 0;
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.ImportStatus != enums.ImportStatus.NotSet)
{
para.Add("@FdpImportStatusId", (int)filter.ImportStatus, DbType.Int32);
}
if (!string.IsNullOrEmpty(filter.FilterMessage))
{
para.Add("@FilterMessage", filter.FilterMessage, DbType.String, size: 50);
}
//if (filter.SortIndex.HasValue)
//{
// para.Add("@SortIndex", filter.SortIndex.Value, dbType: DbType.Int32);
//}
para.Add("@SortIndex", filter.SortIndex.GetValueOrDefault(), DbType.Int32);
if (filter.SortDirection != enums.SortDirection.NotSet)
{
var direction = filter.SortDirection == enums.SortDirection.Descending ? "DESC" : "ASC";
para.Add("@SortDirection", direction, DbType.String);
}
else
{
para.Add("@SortDirection", "DESC", DbType.String);
}
para.Add("@TotalPages", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
para.Add("@TotalDisplayRecords", dbType: DbType.Int32, direction: ParameterDirection.Output);
var results = conn.Query<ImportQueueDataItem>("dbo.Fdp_ImportQueue_GetMany", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
totalRecords = para.Get<int>("@TotalRecords");
totalDisplayRecords = para.Get<int>("@TotalDisplayRecords");
}
retVal = new PagedResults<ImportQueue>
{
PageIndex = filter.PageIndex ?? 1,
TotalRecords = totalRecords,
TotalDisplayRecords = totalDisplayRecords,
PageSize = filter.PageSize ?? totalRecords
};
var currentPage = new List<ImportQueue>();
foreach (var result in results)
{
result.ImportType = ImportTypeDataItem.ToImportType(result);
result.ImportStatus = ImportStatusDataItem.ToImportStatus(result);
//HydrateImportErrors(result, conn);
currentPage.Add(ImportQueueDataItem.ToImportQueue(result));
}
retVal.CurrentPage = currentPage;
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public async Task<ImportError> MapDerivative(ImportQueueFilter filter, FdpDerivativeMapping derivativeMapping)
{
var task = await Task.FromResult(_derivativeDataStore.FdpDerivativeMappingSave(derivativeMapping));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<IEnumerable<ImportFeature>> ListImportFeatures(ImportQueueFilter importQueueFilter)
{
return await Task.FromResult(_importDataStore.FdpImportFeaturesGetMany(importQueueFilter));
}
public async Task<IEnumerable<ImportExceptionType>> ListExceptionTypes(ImportQueueFilter filter)
{
return await Task.FromResult(
_importDataStore.ImportExceptionTypeGetMany(filter));
}
public async Task<PagedResults<ImportError>> ListExceptions(ImportQueueFilter filter)
{
return await Task.FromResult(
_importDataStore.ImportErrorGetMany(filter));
}
public async Task<ImportError> MapTrim(ImportQueueFilter filter, FdpTrimMapping trimMapping)
{
var task = await Task.FromResult(_trimDataStore.TrimMappingSave(trimMapping));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<ImportError> AddTrim(ImportQueueFilter filter, FdpTrim trimToAdd)
{
var task = await Task.FromResult(_trimDataStore.FdpTrimSave(trimToAdd));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<ActionResult> ProcessTakeRateData(ImportExceptionParameters parameters)
{
var filter = new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault());
var queuedItem = DataContext.Import.GetImportQueue(filter).Result;
var results = DataContext.Import.ProcessTakeRateData(queuedItem).Result;
if (queuedItem.HasErrors)
{
return Json(JsonActionResult.GetFailure("Import file still contains errors, unable to process take rate data"));
}
if (results == null || !results.TakeRateId.HasValue)
{
return Json(JsonActionResult.GetFailure("Take Rate file not created"), JsonRequestBehavior.AllowGet);
}
// Validate the data for each market
var takeRateParameters = new TakeRateParameters()
{
TakeRateId = results.TakeRateId
};
var takeRateFilter = TakeRateFilter.FromTakeRateParameters(takeRateParameters);
// Get the markets and iterate through them, validating in turn
//var availableMarkets = DataContext.Market.ListMarkets(takeRateFilter).Result;
//foreach (var market in availableMarkets)
//{
// takeRateFilter.Action = TakeRateDataItemAction.Validate;
// takeRateFilter.MarketId = market.Id;
// var takeRateView = await TakeRateViewModel.GetModel(DataContext, takeRateFilter);
// try
// {
// var interimResults = Validator.Validate(takeRateView.RawData);
// await Validator.Persist(DataContext, takeRateFilter, interimResults, true);
// }
// catch (ValidationException vex)
// {
// // Just in case someone has thrown an exception from the validation, which we don't actually want
// Log.Warning(vex);
// }
// catch (Exception ex)
// {
// Log.Error(ex);
// }
//}
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ImportError> MapMarket(ImportQueueFilter filter, FdpMarketMapping mapping)
{
var task = await Task.FromResult(_marketDataStore.FdpMarketMappingSave(mapping));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<ImportError> AddSpecialFeature(ImportQueueFilter filter, FdpSpecialFeature specialFeature)
{
await Task.FromResult(_featureDataStore.FdpSpecialFeatureSave(specialFeature));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<ImportError> AddDerivative(ImportQueueFilter filter, FdpDerivative derivativeToAdd)
{
var task = await Task.FromResult(_derivativeDataStore.FdpDerivativeSave(derivativeToAdd));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public static async Task<ImportViewModel> GetModel(IDataContext context,
ImportQueueFilter filter,
enums.ImportAction action)
{
var model = await GetModel(context, filter);
model.CurrentAction = action;
if (action != enums.ImportAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(action.GetType(), action);
}
return model;
}
public async Task<ImportError> AddFeature(ImportQueueFilter filter, FdpFeature featureToAdd)
{
var task = await Task.FromResult(_featureDataStore.FdpFeatureSave(featureToAdd));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public IEnumerable<ImportFeature> FdpImportFeaturesGetMany(ImportQueueFilter filter)
{
var retVal = Enumerable.Empty<ImportFeature>();
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpImportQueueId", filter.ImportQueueId, DbType.Int32);
retVal = conn.Query<ImportFeature>("Fdp_ImportFeatures_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public async Task<ImportError> MapFeature(ImportQueueFilter filter, FdpFeatureMapping featureMapping)
{
var task = await Task.FromResult(_featureDataStore.FeatureMappingSave(featureMapping));
return await Task.FromResult(_importDataStore.ImportErrorGet(filter));
}
public async Task<ImportSummary> GetImportSummary(ImportQueueFilter filter)
{
return await Task.FromResult(_importDataStore.ImportQueueSummaryGet(filter.ImportQueueId.Value));
}
public static async Task<ImportViewModel> GetModel(IDataContext context,
ImportQueueFilter filter)
{
ImportViewModel model = null;
switch (filter.Action)
{
case enums.ImportAction.ImportQueue:
model = await GetFullAndPartialViewModelForImportQueue(context, filter);
break;
case enums.ImportAction.Exception:
model = await GetFullAndPartialViewModelForException(context, filter);
break;
case enums.ImportAction.ImportQueueItem:
case enums.ImportAction.ProcessTakeRateData:
case enums.ImportAction.DeleteImport:
model = await GetFullAndPartialViewModelForImportQueueItem(context, filter);
break;
case enums.ImportAction.Summary:
model = await GetFullAndPartialViewModelForSummary(context, filter);
break;
default:
model = await GetFullAndPartialViewModel(context);
break;
}
return model;
}
public async Task<ImportError> SaveException(ImportQueueFilter filter)
{
return await Task.FromResult(_importDataStore.ImportExceptionSave(filter));
}
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 async Task<ImportQueue> UpdateStatus(ImportQueueFilter filter)
{
return await Task.FromResult(_importDataStore.ImportQueueUpdateStatus(filter));
}
private static async Task<ImportViewModel> GetFullAndPartialViewModelForSummary(IDataContext context, ImportQueueFilter filter)
{
var model = new ImportViewModel(GetBaseModel(context))
{
Summary = await context.Import.GetImportSummary(filter)
};
return model;
}
public ImportError ImportExceptionSave(ImportQueueFilter filter)
{
ImportError retVal = new EmptyImportError();
using (IDbConnection connection = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpImportErrorId", filter.ExceptionId.Value, DbType.Int32);
para.Add("@IsExcluded", true, DbType.Boolean);
para.Add("@CDSId", CurrentCDSID, DbType.String);
var results = connection.Query<ImportError>("dbo.Fdp_ImportError_Save", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
retVal = results.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
