//[HandleErrorWithJson]
//[HttpPost]
//public async Task<ActionResult> Validate(TakeRateParameters parameters)
//{
// var validationResults = Enumerable.Empty<ValidationResult>();
// TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
// var filter = TakeRateFilter.FromTakeRateParameters(parameters);
// filter.Action = TakeRateDataItemAction.Validate;
// var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
// try
// {
// var interimResults = Validator.Validate(takeRateView.RawData);
// validationResults = await Validator.Persist(DataContext, filter, interimResults);
// }
// 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 JsonGetSuccess(validationResults);
//}
public ActionResult IgnoreValidationError(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
DataContext.TakeRate.IgnoreValidationError(TakeRateFilter.FromTakeRateParameters(parameters));
return(RedirectToRoute("TakeRateDataByMarket", new { takeRateId = parameters.TakeRateId, marketId = parameters.MarketId }));
}
public async Task <ActionResult> ListTakeRates(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.NoValidation);
var js = new JavaScriptSerializer();
var filter = new TakeRateFilter()
{
FilterMessage = parameters.FilterMessage,
TakeRateStatusId = parameters.TakeRateStatusId,
Action = TakeRateDataItemAction.TakeRates
};
filter.InitialiseFromJson(parameters);
var results = await TakeRateViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.TakeRates.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <JsonResult> TakeRateFeatureData(TakeRateParameters parameters)
{
Log.Debug(MethodBase.GetCurrentMethod().Name);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRateDataPage;
var model = await TakeRateViewModel.GetModel(DataContext, filter);
var rows = new List <Dictionary <string, object> >();
foreach (DataRow dr in model.Document.TakeRateData.RawData.Rows)
{
var row = new Dictionary <string, object>();
foreach (DataColumn col in model.Document.TakeRateData.RawData.Columns)
{
row.Add(col.ColumnName, dr[col]);
}
rows.Add(row);
}
Response.AddHeader("Content-Encoding", "gzip");
Response.Filter = new GZipStream(Response.Filter,
CompressionMode.Compress);
return(Json(new
{
FeatureData = rows,
model.Document.Market
}));
}
public async Task <ActionResult> Clone(TakeRateParameters parameters)
{
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
var clone = await DataContext.TakeRate.CloneTakeRateDocument(filter);
// Revalidate the clone, as the new document may have different feature applicability
filter = new TakeRateFilter()
{
TakeRateId = clone.TakeRateId
};
var markets = await DataContext.Market.ListMarkets(filter);
foreach (var market in markets)
{
try
{
filter.MarketId = market.Id;
var rawData = await DataContext.TakeRate.GetRawData(filter);
//var validationResults = Validator.Validate(rawData);
//Validator.Persist(DataContext, filter, validationResults);
}
catch (ValidationException vex)
{
// Sink the exception, as we don't want any validation errors propagating up
}
catch (Exception ex)
{
}
}
return(JsonGetSuccess(clone));
}
//[OutputCache(Duration = 600,
// VaryByParam = "TakeRateParameters.TakeRateId,TakeRateParameters.MarketId,TakeRateParameters.PageSize,TakeRateParameters.PageIndex")]
//[SiteMapTitle("DocumentName")]
public ActionResult TakeRateDataPage(TakeRateParameters parameters)
{
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRateDataPage;
var model = TakeRateViewModel.GetModel(DataContext, filter).Result;
var title = string.Format("{0} - {1} ({2}) - {3}",
model.Document.Vehicle.Code,
model.Document.Vehicle.ModelYear, model.Document.UnderlyingOxoDocument.Gateway,
model.Document.TakeRateSummary.First().Version);
ViewBag.Title = title;
string displayName;
if (model.Document.Market is EmptyMarket)
{
displayName = string.Format("{0} - ALL MARKETS", title);
}
else
{
displayName = string.Format("{0} - {1}",
title,
model.Document.Market.Name.ToUpper());
}
ViewData["DocumentName"] = displayName;
return(View("TakeRateDataPage", model));
}
public async Task <ActionResult> GetLatestChangeset(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var changeset = await DataContext.TakeRate.GetUnsavedChangesForUser(TakeRateFilter.FromTakeRateParameters(parameters));
return(Json(changeset));
}
public async Task <ActionResult> ModalContent(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var takeRateView = await GetModelFromParameters(parameters);
return(PartialView(GetContentPartialViewName(parameters.Action), takeRateView));
}
public async Task <ActionResult> ModalAction(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, Enum.GetName(parameters.Action.GetType(), parameters.Action));
return(RedirectToRoute(Enum.GetName(parameters.Action.GetType(), parameters.Action), parameters.GetActionSpecificParameters()));
}
public static TakeRateFilter FromTakeRateParameters(TakeRateParameters parameters)
{
var filter = new TakeRateFilter
{
TakeRateId = parameters.TakeRateId,
DocumentId = parameters.DocumentId,
TakeRateDataItemId = parameters.TakeRateDataItemId,
TakeRateStatusId = parameters.TakeRateStatusId,
Mode = parameters.Mode,
Action = parameters.Action,
MarketGroupId = parameters.MarketGroupId,
MarketId = parameters.MarketId,
Comment = parameters.Comment,
MarketReviewStatus = parameters.MarketReviewStatus,
Filter = parameters.Filter,
PageSize = parameters.PageSize,
PageIndex = parameters.PageIndex,
FdpValidationId = parameters.FdpValidationId,
ChangesetId = parameters.ChangesetId,
BMC = parameters.BMC,
DPCK = parameters.DPCK,
FeatureCode = parameters.FeatureCode,
ShowCombinedPackOptions = parameters.ShowCombinedPackOptions
};
if (!string.IsNullOrEmpty(parameters.ModelIdentifier))
{
if (parameters.ModelIdentifier.StartsWith("O"))
{
filter.ModelId = int.Parse(parameters.ModelIdentifier.Substring(1));
}
else
{
filter.FdpModelId = int.Parse(parameters.ModelIdentifier.Substring(1));
}
}
if (string.IsNullOrEmpty(parameters.FeatureIdentifier))
{
return(filter);
}
if (parameters.FeatureIdentifier.StartsWith("O"))
{
filter.FeatureId = int.Parse(parameters.FeatureIdentifier.Substring(1));
}
else if (parameters.FeatureIdentifier.StartsWith("P"))
{
filter.FeaturePackId = int.Parse(parameters.FeatureIdentifier.Substring(1));
}
else
{
filter.FdpFeatureId = int.Parse(parameters.FeatureIdentifier.Substring(1));
}
return(filter);
}
public async Task <ActionResult> Publish(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifierWithCommentAndMarket);
var publish = await DataContext.TakeRate.SetPublish(
TakeRateFilter.FromTakeRateParameters(parameters));
return(Json(publish));
}
public async Task <ActionResult> Powertrain(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.Powertrain;
var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
return(PartialView("_Powertrain", takeRateView));
}
private void CheckModelAllowsEdit(TakeRateParameters parameters)
{
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.Changeset;
var takeRateView = TakeRateViewModel.GetModel(DataContext, filter).Result;
if (!takeRateView.AllowEdit)
{
throw new InvalidOperationException(NO_EDITS);
}
}
public async Task <ActionResult> TakeRatePage(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.NoValidation);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRates;
var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
return(View("TakeRatePage", takeRateView));
}
public async Task <ActionResult> PersistChangeset(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters,
TakeRateParametersValidator.TakeRateIdentifierWithChangesetAndComment);
CheckModelAllowsEdit(parameters);
var persistedChangeset =
await DataContext.TakeRate.PersistChangeset(TakeRateFilter.FromTakeRateParameters(parameters));
return(Json(persistedChangeset));
}
protected override bool IsValid(PropertyValidatorContext context)
{
Parameters = context.ParentContext.InstanceToValidate as TakeRateParameters;
var changes = context.PropertyValue as IEnumerable <DataChange>;
if (changes != null)
{
return(!changes.Any(IsVolumeGreaterThanVolumeForMarket));
}
return(true);
}
public async Task <ActionResult> PersistChangesetConfirm(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifierWithChangeset);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRateDataItemDetails;
var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
takeRateView.Changes = await DataContext.TakeRate.GetUnsavedChangesForUser(filter);
return(PartialView("_PersistChangesetConfirm", takeRateView));
}
public async Task <ActionResult> ChangesetHistory(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.Changeset;
var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
takeRateView.History = await DataContext.TakeRate.GetChangesetHistory(filter);
return(PartialView("_ChangesetHistory", takeRateView));
}
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));
}
private async Task CheckModelAllowsEdit(TakeRateParameters parameters)
{
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.Publish;
var takeRateView = await TakeRateViewModel.GetModel(
DataContext,
filter);
if (!takeRateView.AllowEdit)
{
throw new InvalidOperationException(NoEdits);
}
}
public async Task <ActionResult> GetValidationSummary(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.ValidationSummary;
var takeRateView = await TakeRateViewModel.GetModel(DataContext, filter);
var validation = await DataContext.TakeRate.GetValidation(TakeRateFilter.FromTakeRateParameters(parameters));
takeRateView.Validation = validation;
return(PartialView("_ValidationSummary", takeRateView));
}
public ActionResult SaveChangeset(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters,
TakeRateParametersValidator.TakeRateIdentifierWithChangeset);
CheckModelAllowsEdit(parameters);
var business = new TakeRateBusiness(DataContext, parameters);
business.CalculateChanges();
business.SaveChangeset();
return(Json(business.CurrentChangeSet));
}
public async Task <ActionResult> GetValidation(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var validation = new FdpValidation();
if (parameters.MarketId.HasValue)
{
var business = new TakeRateBusiness(DataContext, parameters);
business.ValidateChangeset();
validation = await DataContext.TakeRate.GetValidation(TakeRateFilter.FromTakeRateParameters(parameters));
}
return(Json(validation));
}
public async Task <JsonResult> Markets(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var marketsGroups =
await DataContext.TakeRate.ListAvailableMarketGroups(TakeRateFilter.FromTakeRateParameters(parameters));
var markets = marketsGroups.SelectMany(mg => mg.Markets).Select(m => new
{
m.Name,
m.GroupName,
m.VariantCount,
m.LastUpdated,
m.UpdatedBy
});
return(Json(markets, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> AddNote(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.ModelPlusFeatureAndComment);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.AddNote;
var takeRateView = TakeRateViewModel.GetModel(DataContext, filter).Result;
if (!takeRateView.AllowEdit)
{
throw new InvalidOperationException(NO_EDITS);
}
var note = await DataContext.TakeRate.AddDataItemNote(TakeRateFilter.FromTakeRateParameters(parameters));
return(Json(note, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> MarketReview(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifierWithCommentAndMarketAndReviewStatus);
await CheckModelAllowsEdit(parameters);
var marketReview = await DataContext.TakeRate.SetMarketReview(
TakeRateFilter.FromTakeRateParameters(parameters));
if (parameters.MarketReviewStatus == MarketReviewStatus.Approved)
{
// Automatically save the changes from the market
parameters.Comment = "Changes from market review";
await DataContext.TakeRate.PersistChangeset(TakeRateFilter.FromTakeRateParameters(parameters));
}
return(Json(marketReview));
}
public async Task <JsonResult> TakeRateModelData(TakeRateParameters parameters)
{
Log.Debug(MethodBase.GetCurrentMethod().Name);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRateDataPage;
var model = await TakeRateViewModel.GetModel(DataContext, filter);
Response.AddHeader("Content-Encoding", "gzip");
Response.Filter = new GZipStream(Response.Filter,
CompressionMode.Compress);
return(Json(new
{
ModelData = model.Document.TakeRateData.TakeRateSummaryByModel,
model.Document.Market
}));
}
public void ExportChangeDetails(TakeRateParameters parameters)
{
TakeRateParametersValidator.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifierWithChangeset);
var business = new TakeRateBusiness(DataContext, parameters);
var exportData = business.ExportChangeset();
Response.ClearContent();
Response.Buffer = true;
Response.AddHeader("content-disposition", "attachment; filename=ChangeHistory.xlsx");
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
using (var stream = new MemoryStream())
{
exportData.SaveAs(stream);
stream.WriteTo(Response.OutputStream);
Response.Flush();
Response.End();
}
}
public async Task <ActionResult> ContextMenu(TakeRateParameters parameters)
{
try
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.TakeRates;
var takeRateView = await TakeRateViewModel.GetModel(
DataContext,
filter);
return(PartialView("_ContextMenu", takeRateView));
}
catch (Exception ex)
{
return(PartialView("_ModalError"));
}
}
//[OutputCacheComplex(typeof(TakeRateParameters))]
public async Task <ActionResult> MarketReviewConfirm(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.TakeRateIdentifier);
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
filter.Action = TakeRateDataItemAction.MarketReview;
var takeRateView = await TakeRateViewModel.GetModel(
DataContext,
filter);
if (parameters.MarketReviewStatus == MarketReviewStatus.Recalled)
{
takeRateView.MarketReviewStatus = MarketReviewStatus.Recalled;
}
takeRateView.Changes = await DataContext.TakeRate.GetUnsavedChangesForUser(filter);
return(PartialView("_MarketReviewConfirm", takeRateView));
}
public void ExportCpat(TakeRateParameters parameters)
{
var business = new TakeRateBusiness(DataContext, parameters, false);
var exportData = business.ExportCpat();
var fileName = string.Format("TakeRateCpatExport_{0:yyyyMMdd}_{1}.xlsx",
DateTime.Now,
parameters.TakeRateId);
Response.ClearContent();
Response.Buffer = true;
Response.AddHeader("content-disposition", "attachment; filename=" + fileName);
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
using (var stream = new MemoryStream())
{
exportData.SaveAs(stream);
stream.WriteTo(Response.OutputStream);
Response.Flush();
Response.End();
}
}
