public async Task <ActionResult> ListMarketMappings(MarketMappingParameters parameters)
{
ValidateMarketMappingParameters(parameters, MarketMappingParametersValidator.NoValidation);
var filter = new MarketMappingFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = MarketMappingAction.Mappings
};
filter.InitialiseFromJson(parameters);
var results = await MarketMappingViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.MarketMappings.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public static async Task <MarketMappingViewModel> GetModel(IDataContext context,
MarketMappingFilter filter)
{
MarketMappingViewModel model = null;
if (filter.Action == MarketMappingAction.Delete ||
filter.Action == MarketMappingAction.Mapping ||
filter.Action == MarketMappingAction.Copy)
{
model = await GetFullAndPartialViewModelForMarketMapping(context, filter);
}
else if (filter.Action == MarketMappingAction.Mappings ||
filter.Action == MarketMappingAction.CopyAll)
{
model = await GetFullAndPartialViewModelForMarketMappings(context, filter);
}
else
{
model = GetFullAndPartialViewModel(context, filter);
}
if (filter.Action != MarketMappingAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(filter.Action.GetType(), filter.Action);
}
return(model);
}
private static async Task <MarketMappingViewModel> GetFullAndPartialViewModelForMarketMapping
(
IDataContext context,
MarketMappingFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new MarketMappingViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var marketMapping = await context.Market.GetFdpMarketMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = marketMapping.ProgrammeId,
Gateway = marketMapping.Gateway,
Code = model.MarketMapping.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
if (!(marketMapping is EmptyFdpMarketMapping))
{
marketMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == marketMapping.ProgrammeId.GetValueOrDefault());
}
model.MarketMapping = marketMapping;
return(model);
}
public FdpMarketMapping FdpMarketMappingGet(MarketMappingFilter filter)
{
FdpMarketMapping retVal = new EmptyFdpMarketMapping();
using (var conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpMarketMappingId", filter.MarketMappingId.GetValueOrDefault(), DbType.Int32);
var results = conn.Query <FdpMarketMapping>("Fdp_MarketMapping_Get", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
retVal = results.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public async Task <ActionResult> ModalContent(MarketMappingParameters parameters)
{
ValidateMarketMappingParameters(parameters, MarketMappingParametersValidator.Action);
var filter = MarketMappingFilter.FromMarketMappingParameters(parameters);
var derivativeMappingView = await MarketMappingViewModel.GetModel(DataContext, filter);
return(PartialView(GetContentPartialViewName(parameters.Action), derivativeMappingView));
}
public async Task <ActionResult> MarketMappingPage(MarketMappingParameters parameters)
{
var filter = new MarketMappingFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await MarketMappingViewModel.GetModel(DataContext, filter)));
}
public async Task <ActionResult> ContextMenu(MarketMappingParameters parameters)
{
ValidateMarketMappingParameters(parameters, MarketMappingParametersValidator.MarketMappingIdentifier);
var filter = MarketMappingFilter.FromMarketMappingParameters(parameters);
filter.Action = MarketMappingAction.Mapping;
var derivativeMappingView = await MarketMappingViewModel.GetModel(DataContext, filter);
return(PartialView("_ContextMenu", derivativeMappingView));
}
private static MarketMappingViewModel GetFullAndPartialViewModel(IDataContext context,
MarketMappingFilter filter)
{
var model = new MarketMappingViewModel(SharedModelBase.GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return(model);
}
private static async Task <MarketMappingViewModel> GetFullAndPartialViewModelForMarketMappings
(
IDataContext context,
MarketMappingFilter filter
)
{
var baseModel = SharedModelBase.GetBaseModel(context);
var model = new MarketMappingViewModel(baseModel)
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = filter.ProgrammeId,
Gateway = filter.Gateway
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.MarketMappings = await context.Market.ListFdpMarketMappings(filter);
model.TotalPages = model.MarketMappings.TotalPages;
model.TotalRecords = model.MarketMappings.TotalRecords;
model.TotalDisplayRecords = model.MarketMappings.TotalDisplayRecords;
foreach (var marketMapping in model.MarketMappings.CurrentPage)
{
marketMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == marketMapping.ProgrammeId.GetValueOrDefault());
}
return(model);
}
private async Task <MarketMappingViewModel> GetModelFromParameters(MarketMappingParameters parameters)
{
return(await MarketMappingViewModel.GetModel(DataContext, MarketMappingFilter.FromMarketMappingParameters(parameters)));
}
public async Task <PagedResults <FdpMarketMapping> > ListFdpMarketMappings(MarketMappingFilter filter)
{
return(await Task.FromResult <PagedResults <FdpMarketMapping> >(_marketDataStore.FdpMarketMappingGetMany(filter)));
}
public async Task <FdpMarketMapping> GetFdpMarketMapping(MarketMappingFilter filter)
{
return(await Task.FromResult <FdpMarketMapping>(_marketDataStore.FdpMarketMappingGet(filter)));
}
