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> 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> 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> 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> ListImportQueue(ImportParameters parameters)
{
var filter = new ImportQueueFilter()
{
FilterMessage = parameters.FilterMessage,
ImportStatus = (enums.ImportStatus)parameters.ImportStatusId.GetValueOrDefault(),
Action = ImportAction.ImportQueue
};
filter.InitialiseFromJson(parameters);
var results = await ImportViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results.TotalRecords, results.TotalDisplayRecords);
// Iterate through the results and put them in a format that can be used by jQuery datatables
if (results.ImportQueue.CurrentPage.Any())
{
foreach (var result in results.ImportQueue.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
}
return(Json(jQueryResult));
}
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> 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 ImportError ImportExceptionIgnore(ImportQueueFilter filter, bool reprocess)
{
ImportError retVal = new EmptyImportError();
using (IDbConnection connection = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
para.Add("@ExceptionId", filter.ExceptionId.Value, DbType.Int32);
para.Add("@IsExcluded", true, DbType.Int32);
if (!reprocess)
{
para.Add("@Reprocess", reprocess, DbType.Boolean);
}
var results = connection.Query <ImportError>("dbo.Fdp_ImportErrorExclusion_Save", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
retVal = results.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
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);
}
public ImportError ImportErrorGet(ImportQueueFilter filter)
{
ImportError retVal = new EmptyImportError();
using (var connection = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@ExceptionId", filter.ExceptionId, DbType.Int32);
var results = connection.Query <ImportError>("dbo.Fdp_ImportError_Get", para, commandType: CommandType.StoredProcedure);
var importErrors = results as IList <ImportError> ?? results.ToList();
if (importErrors.Any())
{
retVal = importErrors.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public ImportQueue ImportQueueUpdateStatus(ImportQueueFilter filter)
{
ImportQueue retVal;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@ImportQueueId", filter.ImportQueueId, DbType.Int32);
para.Add("@ImportStatusId", (int)filter.ImportStatus, DbType.Int32);
if (!string.IsNullOrEmpty(filter.ErrorMessage))
{
para.Add("@ErrorMessage", filter.ErrorMessage, DbType.String);
}
retVal = conn
.Query <ImportQueue>("dbo.Fdp_ImportQueue_UpdateStatus", para, commandType: CommandType.StoredProcedure)
.FirstOrDefault();
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
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));
}
private async Task <ImportError> DeactivateException(ImportError exception)
{
var filter = ImportQueueFilter.FromExceptionId(exception.FdpImportErrorId);
filter.IsActive = false;
return(await DataContext.Import.SaveException(filter));
}
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 <ActionResult> DeleteImport(ImportParameters parameters)
{
var filter = new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault());
var importView = await GetModelFromParameters(parameters);
filter.ImportStatus = enums.ImportStatus.Cancelled;
importView.CurrentImport = await DataContext.Import.UpdateStatus(filter);
return(Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet));
}
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> 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> 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> 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> 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 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);
}
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 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> 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 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 <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> 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));
}
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);
}
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));
}
