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<ActionResult> ImportSummary(ImportExceptionParameters parameters)
{
var importView = await ImportViewModel.GetModel(DataContext,
new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault())
{
Action = ImportAction.Summary
});
return PartialView("_ImportSummary", importView);
}
public async Task<ActionResult> ImportExceptionsPage(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ImportQueueIdentifier);
var importView = await ImportViewModel.GetModel(DataContext,
new ImportQueueFilter(parameters.ImportQueueId.Value)
{
ExceptionType = parameters.ExceptionType,
PageIndex = PageIndex,
PageSize = PageSize,
Action = ImportAction.ImportQueueItem
});
var displayName = string.Format("Import Exceptions - {0} - {1:dd/MM/yyyy}", importView.Programme.ToShortString(), importView.CurrentImport.CreatedOn);
ViewData["ImportName"] = displayName;
return View(importView);
}
public async Task<ActionResult> IgnoreException(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
importView.CurrentException = await DataContext.Import.IgnoreException(filter);
//await DeactivateException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> IgnoreAll(ImportExceptionParameters parameters)
{
parameters.ExceptionIds = (IEnumerable<int>) TempData["IgnoreAll"];
var exceptionIds = parameters.ExceptionIds as IList<int> ?? parameters.ExceptionIds.ToList();
var lastExceptionId = exceptionIds.Last();
foreach (var exceptionId in exceptionIds)
{
var filter = ImportQueueFilter.FromExceptionId(exceptionId);
await DataContext.Import.IgnoreException(filter, exceptionId == lastExceptionId);
}
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> MapMissingMarket(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var marketMapping = new FdpMarketMapping()
{
ImportMarket = parameters.ImportMarket,
MarketId = parameters.MarketId,
ProgrammeId = parameters.ProgrammeId,
Gateway = parameters.Gateway,
IsGlobalMapping = parameters.IsGlobalMapping
};
importView.CurrentException = await DataContext.Import.MapMarket(filter, marketMapping);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
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<ActionResult> MapMissingFeature(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var feature = importView.AvailableFeatures
.First(f => f.FeatureCode.Equals(parameters.FeatureCode, StringComparison.InvariantCultureIgnoreCase));
var featureMapping = new FdpFeatureMapping()
{
ImportFeatureCode = parameters.ImportFeatureCode,
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
FeatureId = feature.FeatureId,
FeaturePackId = feature.FeaturePackId
};
importView.CurrentException = await DataContext.Import.MapFeature(filter, featureMapping);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> MapMissingTrim(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var trimMapping = new FdpTrimMapping()
{
ImportTrim = parameters.ImportTrim,
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
DocumentId = parameters.DocumentId
};
if (!string.IsNullOrEmpty(parameters.TrimIdentifier))
{
if (parameters.TrimIdentifier.StartsWith("F"))
{
trimMapping.FdpTrimId = int.Parse(parameters.TrimIdentifier.Substring(1));
}
else
{
trimMapping.TrimId = int.Parse(parameters.TrimIdentifier.Substring(1));
}
}
importView.CurrentException = await DataContext.Import.MapTrim(filter, trimMapping);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> RefreshWorktray(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ImportQueueIdentifier);
var filter = ImportQueueFilter.FromParameters(parameters);
var queuedItem = await DataContext.Import.GetImportQueue(filter);
DataContext.Import.ReprocessImportQueue(queuedItem);
return RedirectToAction("ImportExceptionsPage", parameters);
}
public async Task<ActionResult> AddMissingFeature(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var feature = new FdpFeature()
{
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
FeatureCode = parameters.ImportFeatureCode,
BrandDescription = parameters.FeatureDescription,
FeatureGroupId = parameters.FeatureGroupId
};
importView.CurrentException = await DataContext.Import.AddFeature(filter, feature);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> MapOxoDerivative(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault());
var derivative = Derivative.FromIdentifier(parameters.DerivativeCode);
var importView = await GetModelFromParameters(parameters);
var importDerivatives = (IEnumerable<string>) TempData["MapOxoDerivative"];
foreach (var importDerivative in importDerivatives)
{
var derivativeMapping = new FdpDerivativeMapping()
{
ImportDerivativeCode = importDerivative,
DocumentId = parameters.DocumentId.GetValueOrDefault(),
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
DerivativeCode = derivative.DerivativeCode,
BodyId = derivative.BodyId.GetValueOrDefault(),
EngineId = derivative.EngineId.GetValueOrDefault(),
TransmissionId = derivative.TransmissionId.GetValueOrDefault()
};
await DataContext.Import.MapDerivative(filter, derivativeMapping);
}
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> MapOxoTrim(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault());
var trim = ModelTrim.FromIdentifier(parameters.TrimIdentifier);
var importView = await GetModelFromParameters(parameters);
var importTrimLevels = (IEnumerable<string>)TempData["MapOxoTrim"];
foreach (var importTrimLevel in importTrimLevels)
{
var trimMapping = new FdpTrimMapping()
{
ImportTrim = importTrimLevel,
DocumentId = parameters.DocumentId.GetValueOrDefault(),
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
TrimId = trim.Id
};
await DataContext.Import.MapTrim(filter, trimMapping);
}
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> MapMissingDerivative(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault());
var derivative = Derivative.FromIdentifier(parameters.DerivativeCode);
var importView = await GetModelFromParameters(parameters);
//var derivative = importView.AvailableDerivatives
// .First(d => d.DerivativeCode.Equals(parameters.DerivativeCode, StringComparison.InvariantCultureIgnoreCase));
var derivativeMapping = new FdpDerivativeMapping()
{
ImportDerivativeCode = parameters.ImportDerivativeCode,
DocumentId = parameters.DocumentId.GetValueOrDefault(),
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
DerivativeCode = derivative.DerivativeCode,
BodyId = derivative.BodyId.GetValueOrDefault(),
EngineId = derivative.EngineId.GetValueOrDefault(),
TransmissionId = derivative.TransmissionId.GetValueOrDefault()
};
importView.CurrentException = await DataContext.Import.MapDerivative(filter, derivativeMapping);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> AddSpecialFeature(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var importFeatures = (IEnumerable<string>)TempData["AddSpecialFeature"];
foreach (var importFeature in importFeatures)
{
var specialFeature = new FdpSpecialFeature()
{
DocumentId = parameters.DocumentId.GetValueOrDefault(),
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
FeatureCode = importFeature,
Type = new FdpSpecialFeatureType()
{
FdpSpecialFeatureTypeId = parameters.SpecialFeatureTypeId
}
};
await DataContext.Import.AddSpecialFeature(filter, specialFeature);
}
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> AddMissingTrim(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var trim = new FdpTrim()
{
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
Name = parameters.TrimName,
Abbreviation = parameters.TrimAbbreviation,
Level = parameters.TrimLevel,
DPCK = parameters.DPCK,
BMC = parameters.DerivativeCode
};
importView.CurrentException = await DataContext.Import.AddTrim(filter, trim);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
private async Task<ImportViewModel> GetModelFromParameters(ImportExceptionParameters parameters)
{
if (parameters.Action == ImportAction.ProcessTakeRateData)
{
return await ImportViewModel.GetModel(
DataContext,
new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault()) { Action = parameters.Action },
parameters.Action);
}
return await ImportViewModel.GetModel(
DataContext,
ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault()),
parameters.Action);
}
public ActionResult ModalAction(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ExceptionIdentifierWithActionProgrammeAndGateway);
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, Enum.GetName(parameters.Action.GetType(), parameters.Action));
if (parameters.Action == ImportAction.MapOxoDerivative)
{
TempData["MapOxoDerivative"] = parameters.ImportDerivativeCodes;
}
if (parameters.Action == ImportAction.IgnoreAll)
{
TempData["IgnoreAll"] = parameters.ExceptionIds;
}
if (parameters.Action == ImportAction.MapOxoTrim)
{
TempData["MapOxoTrim"] = parameters.ImportTrimLevels;
}
if (parameters.Action == ImportAction.MapOxoFeature)
{
TempData["MapOxoFeature"] = parameters.ImportFeatureCodes;
}
if (parameters.Action == ImportAction.AddSpecialFeature)
{
TempData["AddSpecialFeature"] = parameters.ImportFeatureCodes;
}
return RedirectToAction(Enum.GetName(parameters.Action.GetType(), parameters.Action), parameters.GetActionSpecificParameters());
}
public async Task<ActionResult> MapOxoFeature(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault());
var feature = FdpFeature.FromIdentifier(parameters.FeatureIdentifier);
var importView = await GetModelFromParameters(parameters);
var importFeatures = (IEnumerable<string>)TempData["MapOxoFeature"];
foreach (var importFeature in importFeatures)
{
var featureMapping = new FdpFeatureMapping()
{
ImportFeatureCode = importFeature,
DocumentId = parameters.DocumentId.GetValueOrDefault(),
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
FeatureCode = feature.FeatureCode
};
if (feature.FeaturePackId.HasValue)
{
featureMapping.FeaturePackId = feature.FeaturePackId;
}
else
{
featureMapping.FeatureId = feature.FeatureId;
}
await DataContext.Import.MapFeature(filter, featureMapping);
}
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> AddMissingDerivative(ImportExceptionParameters parameters)
{
var filter = ImportQueueFilter.FromExceptionId(parameters.ExceptionId.Value);
var importView = await GetModelFromParameters(parameters);
var derivative = new FdpDerivative()
{
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
Gateway = parameters.Gateway,
DerivativeCode = parameters.DerivativeCode,
BodyId = parameters.BodyId.GetValueOrDefault(),
EngineId = parameters.EngineId.GetValueOrDefault(),
TransmissionId = parameters.TransmissionId.GetValueOrDefault()
};
importView.CurrentException = await DataContext.Import.AddDerivative(filter, derivative);
await DeactivateException(importView.CurrentException);
await ReProcessException(importView.CurrentException);
return Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> ContextMenu(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ExceptionIdentifier);
var importView = await ImportViewModel.GetModel(
DataContext,
ImportQueueFilter.FromExceptionId(parameters.ExceptionId.GetValueOrDefault()));
return PartialView("_ContextMenu", importView);
}
public async Task<ActionResult> ModalContent(ImportExceptionParameters parameters)
{
ImportExceptionParametersValidator
.ValidateImportExceptionParameters(parameters, ImportExceptionParametersValidator.ExceptionIdentifierWithAction);
var importView = await GetModelFromParameters(parameters);
return PartialView(GetContentPartialViewName(parameters.Action), importView);
}