public static IEnumerable<ValidationResult> Persist(IDataContext context,
TakeRateFilter filter,
FluentValidation.Results.ValidationResult results,
bool global)
{
return context.TakeRate.PersistValidationErrors(filter, results, global);
}
public TakeRateDataItem TakeRateModelSummaryItemGet(TakeRateFilter filter)
{
TakeRateDataItem retVal;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpVolumeHeaderId", filter.TakeRateId, DbType.Int32);
para.Add("@MarketId", filter.MarketId, DbType.Int32);
para.Add("@ModelId", filter.ModelId, DbType.Int32);
para.Add("@FdpModelId", filter.FdpModelId, DbType.Int32);
var results = conn.QueryMultiple(fdpTakeRateModelSummaryItemGetStoredProcedureName, para, commandType: CommandType.StoredProcedure);
retVal = results.Read<TakeRateDataItem>().First();
retVal.Notes = results.Read<TakeRateDataItemNote>();
retVal.History = results.Read<TakeRateDataItemAudit>();
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public static TakeRateFilter FromTakeRateViewModel(TakeRateViewModel takeRateViewModel)
{
var filter = new TakeRateFilter()
{
ProgrammeId = takeRateViewModel.Document.UnderlyingOxoDocument.ProgrammeId,
Gateway = takeRateViewModel.Document.UnderlyingOxoDocument.Gateway
};
if (!(takeRateViewModel.Document.UnderlyingOxoDocument is EmptyOxoDocument))
{
filter.TakeRateId = takeRateViewModel.Document.TakeRateId;
filter.DocumentId = takeRateViewModel.Document.UnderlyingOxoDocument.Id;
}
if (!(takeRateViewModel.Document.Market is EmptyMarket))
filter.MarketId = takeRateViewModel.Document.Market.Id;
if (!(takeRateViewModel.Document.MarketGroup is EmptyMarketGroup))
filter.MarketGroupId = takeRateViewModel.Document.MarketGroup.Id;
if (!(takeRateViewModel.Document.Vehicle is EmptyVehicle))
filter.Models = takeRateViewModel.Document.Vehicle.AvailableModels;
filter.Mode = takeRateViewModel.Document.Mode;
filter.FeatureCode = takeRateViewModel.Document.FeatureCode;
filter.ShowCombinedPackOptions = takeRateViewModel.Document.ShowCombinedPackOptions;
filter.ExcludeOptionalPackItems = takeRateViewModel.Document.ExcludeOptionalPackItems;
return filter;
}
public async Task<TakeRateData> GetTakeRateDocumentFeatures(TakeRateFilter filter)
{
if (!IsFilterValidForTakeRateData(filter))
return new TakeRateData();
return await Task.FromResult(_takeRateDataStore.TakeRateDataItemFeatureList(filter));
}
private static async Task<PublishViewModel> GetFullAndPartialViewModel(IDataContext context,
TakeRateFilter filter)
{
var model = new PublishViewModel(GetBaseModel(context));
model.AvailableFiles = await context.TakeRate.ListPublish(filter);
return model;
}
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);
}
private static async Task<MarketReviewViewModel> GetFullAndPartialViewModel(IDataContext context,
TakeRateFilter filter)
{
var model = new MarketReviewViewModel(GetBaseModel(context));
if (filter.Action == TakeRateDataItemAction.MarketReview)
{
model.AvailableMarketReviews = await context.TakeRate.ListMarketReview(filter);
};
return model;
}
public async Task<TakeRateDataItem> GetDataItem(TakeRateFilter filter)
{
if (filter.FeatureId.HasValue || filter.FdpFeatureId.HasValue)
{
return await Task.FromResult(_takeRateDataStore.TakeRateDataItemGet(filter));
}
if (filter.ModelId.HasValue || filter.FdpModelId.HasValue)
{
return await Task.FromResult(_takeRateDataStore.TakeRateModelSummaryItemGet(filter));
}
return new EmptyTakeRateDataItem();
}
public MarketGroup GetMarketGroup(TakeRateFilter filter)
{
if (!filter.MarketGroupId.HasValue || !filter.TakeRateId.HasValue)
return new EmptyMarketGroup();
var marketGroup = _marketGroupDataStore.FdpMarketGroupGet(filter);
if (marketGroup == null)
return new EmptyMarketGroup();
// Populate the list of available derivatives for that market (including FDP derivatives)
var variants = _modelDataStore.FdpAvailableModelByMarketGroupGetMany(filter);
marketGroup.VariantCount = variants.Count();
return marketGroup;
}
public static ITakeRateDocument FromFilter(TakeRateFilter filter)
{
var volume = new TakeRateDocument();
if (filter.TakeRateId.HasValue)
{
volume.TakeRateId = filter.TakeRateId;
}
volume.UnderlyingOxoDocument = filter.DocumentId.HasValue ? new OXODoc() {Id = filter.DocumentId.Value} : new EmptyOxoDocument();
if (filter.ProgrammeId.HasValue)
{
volume.Vehicle = new Vehicle() { ProgrammeId = filter.ProgrammeId.Value, Gateway = filter.Gateway };
}
if (filter.MarketGroupId.HasValue)
{
volume.MarketGroup = new MarketGroup() { Id = filter.MarketGroupId.Value };
}
if (filter.MarketId.HasValue)
{
volume.Market = new Market() { Id = filter.MarketId.Value };
}
if (!string.IsNullOrEmpty(filter.BMC))
{
volume.BMC = filter.BMC;
}
if (!string.IsNullOrEmpty(filter.DPCK))
{
volume.DPCK = filter.DPCK;
}
if (!string.IsNullOrEmpty(filter.FeatureCode))
{
volume.FeatureCode = filter.FeatureCode;
}
volume.Mode = filter.Mode;
return volume;
}
public IEnumerable<Market> MarketGetMany(TakeRateFilter filter)
{
IEnumerable<Market> retVal;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpVolumeHeaderId", filter.TakeRateId, DbType.Int32);
retVal = conn.Query<Market>("dbo.Fdp_Market_GetMany", para, commandType: CommandType.StoredProcedure);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public async Task<ActionResult> ListPublish(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.NoValidation);
var filter = new TakeRateFilter()
{
FilterMessage = parameters.FilterMessage,
Action = TakeRateDataItemAction.Publish
};
filter.InitialiseFromJson(parameters);
var results = await PublishViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.AvailableFiles.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return Json(jQueryResult);
}
public IEnumerable<FdpModel> FdpAvailableModelByMarketGetMany(TakeRateFilter filter)
{
var retVal = Enumerable.Empty<FdpModel>();
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpVolumeHeaderId", filter.TakeRateId, DbType.Int32);
para.Add("@MarketId", filter.MarketId, DbType.Int32);
para.Add("@BMC", filter.BMC, DbType.String);
para.Add("@DPCK", filter.DPCK, DbType.String);
para.Add("@PageIndex", filter.PageIndex, DbType.Int32);
para.Add("@PageSize", filter.PageSize, DbType.Int32);
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);
retVal = conn.Query<FdpModel>("dbo.Fdp_AvailableModelByMarket_GetMany", para, commandType: CommandType.StoredProcedure);
if (retVal != null && retVal.Any())
{
filter.TotalRecords = para.Get<int>("@TotalRecords");
filter.TotalDisplayRecords = para.Get<int>("@TotalDisplayRecords");
filter.TotalPages = para.Get<int>("@TotalPages");
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
public IEnumerable<MarketGroup> FdpMarketGroupGetMany(TakeRateFilter filter)
{
IEnumerable<MarketGroup> retVal;
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
para.Add("@FdpVolumeHeaderId", filter.TakeRateId, DbType.Int32);
using (var results = conn.QueryMultiple("dbo.Fdp_MarketGroup_GetMany", para, commandType: CommandType.StoredProcedure))
{
var marketGroups = results.Read<MarketGroup>().ToList();
var markets = results.Read<Market>().ToList();
foreach (var marketGroup in marketGroups)
{
marketGroup.Markets = markets.Where(c => c.ParentId == marketGroup.Id).ToList();
}
marketGroups = marketGroups.Where(mg => mg.Markets.Any()).ToList();
retVal = marketGroups;
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return retVal;
}
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 static TakeRateFilter FromTakeRateViewModel(TakeRateViewModel takeRateViewModel)
{
var filter = new TakeRateFilter()
{
ProgrammeId = takeRateViewModel.Document.UnderlyingOxoDocument.ProgrammeId,
Gateway = takeRateViewModel.Document.UnderlyingOxoDocument.Gateway
};
if (!(takeRateViewModel.Document.UnderlyingOxoDocument is EmptyOxoDocument))
{
filter.TakeRateId = takeRateViewModel.Document.TakeRateId;
filter.DocumentId = takeRateViewModel.Document.UnderlyingOxoDocument.Id;
}
if (!(takeRateViewModel.Document.Market is EmptyMarket))
{
filter.MarketId = takeRateViewModel.Document.Market.Id;
}
if (!(takeRateViewModel.Document.MarketGroup is EmptyMarketGroup))
{
filter.MarketGroupId = takeRateViewModel.Document.MarketGroup.Id;
}
if (!(takeRateViewModel.Document.Vehicle is EmptyVehicle))
{
filter.Models = takeRateViewModel.Document.Vehicle.AvailableModels;
}
filter.Mode = takeRateViewModel.Document.Mode;
filter.FeatureCode = takeRateViewModel.Document.FeatureCode;
filter.ShowCombinedPackOptions = takeRateViewModel.Document.ShowCombinedPackOptions;
filter.ExcludeOptionalPackItems = takeRateViewModel.Document.ExcludeOptionalPackItems;
return(filter);
}
public async Task<Publish> GetPublish(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.FdpPublishGet(filter));
}
public async Task<PagedResults<TakeRateSummary>> ListTakeRateDocuments(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.FdpTakeRateHeaderGetManyByUsername(filter));
}
public async Task<PagedResults<Publish>> ListPublish(TakeRateFilter filter)
{
var publish = await Task.FromResult(_takeRateDataStore.FdpPublishGetMany(filter));
foreach (var currentPublish in publish.CurrentPage)
{
currentPublish.Programme = _programmeDataStore.ProgrammeGet(currentPublish.ProgrammeId);
currentPublish.Document = _documentDataStore.OXODocGet(currentPublish.DocumentId,
currentPublish.ProgrammeId);
}
return publish;
}
public void IgnoreValidationError(TakeRateFilter takeRateFilter)
{
_takeRateDataStore.FdpValidationIgnore(takeRateFilter);
}
public async Task<TakeRateSummary> GetTakeRateDocumentHeader(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.FdpTakeRateHeaderGet(filter));
}
public async Task<IEnumerable<TakeRateDataItemNote>> ListDataItemNotes(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.TakeRateDataItemNoteGetMany(filter));
}
public async Task<MarketReview> SetMarketReview(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.FdpMarketReviewSave(filter));
}
public async Task<Publish> SetPublish(TakeRateFilter takeRateFilter)
{
return await Task.FromResult(_takeRateDataStore.FdpPublishSave(takeRateFilter));
}
private bool IsFilterValidForTakeRateData(TakeRateFilter filter)
{
//return filter.DocumentId.HasValue && (filter.MarketId.HasValue || filter.MarketGroupId.HasValue);
return filter.DocumentId.HasValue;
}
public async Task<RawTakeRateData> GetRawData(TakeRateFilter filter)
{
var rawData = new RawTakeRateData()
{
DataItems = await Task.FromResult(_takeRateDataStore.FdpTakeRateDataGetRaw(filter)),
SummaryItems = await Task.FromResult(_takeRateDataStore.FdpTakeRateSummaryGetRaw(filter)),
FeatureMixItems = await Task.FromResult(_takeRateDataStore.FdpTakeRateFeatureMixGetRaw(filter)),
PowertrainDataItems = await ListPowertrainData(filter),
PackFeatures = await Task.FromResult(_takeRateDataStore.FdpFeaturePackItemsGetMany(filter)),
TotalVolume = await GetVolumeForAllOtherMarkets(filter)
};
return rawData;
}
public async Task<ITakeRateDocument> GetTakeRateDocument(TakeRateFilter filter)
{
return await Task.FromResult(TakeRateDocument.FromFilter(filter));
}
public async Task<TakeRateSummary> CloneTakeRateDocument(TakeRateFilter filter)
{
return await Task.FromResult(_takeRateDataStore.FdpTakeRateDataClone(filter));
}
public async Task<PagedResults<MarketReview>> ListMarketReview(TakeRateFilter filter)
{
var marketReview = await Task.FromResult(_takeRateDataStore.FdpMarketReviewGetMany(filter));
foreach (var currentMarketReview in marketReview.CurrentPage)
{
currentMarketReview.Programme = _programmeDataStore.ProgrammeGet(currentMarketReview.ProgrammeId);
currentMarketReview.Document = _documentDataStore.OXODocGet(currentMarketReview.DocumentId,
currentMarketReview.ProgrammeId);
}
return marketReview;
}
public async Task<IEnumerable<RawPowertrainDataItem>> ListPowertrainData(TakeRateFilter takeRateFilter)
{
return await Task.FromResult(_takeRateDataStore.FdpPowertrainDataItemGetRaw(takeRateFilter));
}
public async Task<OXODoc> GetUnderlyingOxoDocument(TakeRateFilter filter)
{
OXODoc document = new EmptyOxoDocument();
if (!filter.DocumentId.HasValue)
{
var summary = _takeRateDataStore.FdpTakeRateHeaderGet(filter);
document = _documentDataStore.OXODocGet(summary.OxoDocId, filter.ProgrammeId.GetValueOrDefault());
}
else
{
document = _documentDataStore.OXODocGet(filter.DocumentId.Value, filter.ProgrammeId.GetValueOrDefault());
}
return await Task.FromResult(document);
}
public async Task<IEnumerable<MarketGroup>> ListAvailableMarketGroups(TakeRateFilter filter)
{
return await Task.FromResult(_marketGroupDataStore.FdpMarketGroupGetMany(filter));
}
