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 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> 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> 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 virtual IActionResult Get([FromBody] RequestSetting requestSetting)
{
if (requestSetting == null)
{
requestSetting = new RequestSetting();
}
else if (!string.IsNullOrEmpty(requestSetting.FilterText))
{
IsFilterServiceInjected();
requestSetting.Filters = AdvanceFilterQuery.GetDefaultFilter(
Filters.GetFilters(ControllerName),
requestSetting.FilterText
);
}
var data = Service.GetPage(requestSetting);
var result = new JsonActionResult(
data,
InternalSetting(requestSetting),
requestSetting.Page?.RowCount ?? data?.Count
);
return(result);
}
public override void OnException(ExceptionContext filterContext)
{
var statusCode = HttpStatusCode.InternalServerError;
if (CanIgnoreException(filterContext))
{
return;
}
if (!filterContext.HttpContext.Request.IsAjaxRequest())
{
base.OnException(filterContext);
return;
}
if (filterContext.Exception is ValidationException)
{
//filterContext.Exception.Message = filterContext.Exception.Message.Replace(Environment.NewLine, "<br/>");
statusCode = HttpStatusCode.BadRequest;
}
filterContext.Result = new JsonResult()
{
Data = JsonActionResult.GetFailure(filterContext.Exception),
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
filterContext.ExceptionHandled = true;
filterContext.HttpContext.Response.Clear();
filterContext.HttpContext.Response.StatusCode = (int)statusCode;
}
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));
}
protected JsonActionResult Json(object data)
{
var jsonActionResult = new JsonActionResult();
var serializer = new JsonSerializer();
var stringWriter = new StringWriter();
var jsonTextWriter = new JsonTextWriter(stringWriter);
serializer.Serialize(jsonTextWriter, data);
jsonActionResult.Data = stringWriter.GetStringBuilder().ToString();
return(jsonActionResult);
}
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));
}
/// <summary>
/// 为 基础操作 提供统一的返回格式，包含try / catch操作。
/// </summary>
/// <typeparam name="TResult">返回值类型</typeparam>
/// <param name="execAction"></param>
/// <returns></returns>
protected JsonActionResult <TResult> SafeExecute <TResult>(Func <TResult> execAction)
{
var result = new JsonActionResult <TResult>();
try
{
result.Data = execAction();
}
catch (Exception ex)
{
LogHelper.Error(ex.ToString());
result.IsSuccessful = false;
result.ErrorMessage = ex.Message;
}
return(result);
}
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 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 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 IActionResult Present(ObjectOutput output)
{
return(JsonActionResult.Ok(output.Object));
}
public IActionResult Present(ActionOutput output)
{
return(JsonActionResult.Ok(output));
}
public JsonResult JsonGetFailure(string message)
{
return(JsonGet(JsonActionResult.GetFailure(message)));
}
public JsonResult JsonGetSuccess(object data, string message)
{
return(JsonGet(JsonActionResult.GetSuccess(data, message)));
}
public JsonResult JsonGetSuccess(object data)
{
return(JsonGet(JsonActionResult.GetSuccess(data)));
}
public JsonResult JsonGetSuccess(string message)
{
return(JsonGet(JsonActionResult.GetSuccess(message)));
}
public JsonResult JsonGetSuccess()
{
return(JsonGet(JsonActionResult.GetSuccess()));
}
