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; }