public FdpSpecialFeatureMapping FdpSpecialFeatureMappingGet(SpecialFeatureMappingFilter filter)
{
FdpSpecialFeatureMapping retVal = new EmptyFdpSpecialFeatureMapping();
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = new DynamicParameters();
para.Add("@FdpSpecialFeatureMappingId", filter.SpecialFeatureMappingId.GetValueOrDefault(), DbType.Int32);
var results = conn.Query <FdpSpecialFeatureMapping>("Fdp_SpecialFeatureMapping_Get", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
retVal = results.First();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
public static async Task <SpecialFeatureMappingViewModel> GetModel(IDataContext context,
SpecialFeatureMappingFilter filter)
{
SpecialFeatureMappingViewModel model;
if (filter.Action == SpecialFeatureMappingAction.Delete ||
filter.Action == SpecialFeatureMappingAction.Mapping ||
filter.Action == SpecialFeatureMappingAction.Copy)
{
model = await GetFullAndPartialViewModelForFeatureMapping(context, filter);
}
else if (filter.Action == SpecialFeatureMappingAction.Mappings ||
filter.Action == SpecialFeatureMappingAction.CopyAll)
{
model = await GetFullAndPartialViewModelForFeatureMappings(context, filter);
}
else
{
model = GetFullAndPartialViewModel(context, filter);
}
if (filter.Action != SpecialFeatureMappingAction.NotSet)
{
model.IdentifierPrefix = Enum.GetName(filter.Action.GetType(), filter.Action);
}
return(model);
}
public async Task <ActionResult> ListSpecialFeatureMappings(SpecialFeatureMappingParameters parameters)
{
ValidateFeatureMappingParameters(parameters, SpecialFeatureMappingParametersValidator.NoValidation);
var filter = new SpecialFeatureMappingFilter()
{
FilterMessage = parameters.FilterMessage,
CarLine = parameters.CarLine,
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
Action = SpecialFeatureMappingAction.Mappings
};
filter.InitialiseFromJson(parameters);
var results = await SpecialFeatureMappingViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.SpecialFeatureMappings.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <ActionResult> ModalContent(SpecialFeatureMappingParameters parameters)
{
ValidateFeatureMappingParameters(parameters, SpecialFeatureMappingParametersValidator.Action);
var filter = SpecialFeatureMappingFilter.FromFeatureMappingParameters(parameters);
var derivativeMappingView = await SpecialFeatureMappingViewModel.GetModel(DataContext, filter);
return(PartialView(GetContentPartialViewName(parameters.Action), derivativeMappingView));
}
public async Task <ActionResult> SpecialFeatureMappingPage(SpecialFeatureMappingParameters parameters)
{
var filter = new SpecialFeatureMappingFilter()
{
PageIndex = PageIndex,
PageSize = PageSize
};
return(View(await SpecialFeatureMappingViewModel.GetModel(DataContext, filter)));
}
public async Task <ActionResult> ContextMenu(SpecialFeatureMappingParameters parameters)
{
ValidateFeatureMappingParameters(parameters, SpecialFeatureMappingParametersValidator.SpecialFeatureMappingIdentifier);
var filter = SpecialFeatureMappingFilter.FromFeatureMappingParameters(parameters);
filter.Action = SpecialFeatureMappingAction.Mapping;
var derivativeMappingView = await SpecialFeatureMappingViewModel.GetModel(DataContext, filter);
return(PartialView("_ContextMenu", derivativeMappingView));
}
private static SpecialFeatureMappingViewModel GetFullAndPartialViewModel(IDataContext context,
SpecialFeatureMappingFilter filter)
{
var model = new SpecialFeatureMappingViewModel(GetBaseModel(context))
{
Configuration = context.ConfigurationSettings,
};
HydrateModelWithCommonProperties(model, context);
return(model);
}
private static async Task <SpecialFeatureMappingViewModel> GetFullAndPartialViewModelForFeatureMapping
(
IDataContext context,
SpecialFeatureMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new SpecialFeatureMappingViewModel()
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : int.MaxValue,
Configuration = context.ConfigurationSettings,
CurrentUser = baseModel.CurrentUser,
CurrentVersion = baseModel.CurrentVersion
};
var featureMapping = await context.Vehicle.GetFdpSpecialFeatureMapping(filter);
var programmeFilter = new ProgrammeFilter()
{
ProgrammeId = featureMapping.ProgrammeId,
Gateway = featureMapping.Gateway,
Code = model.SpecialFeatureMapping.Programme.VehicleName // In order to filter the gateways specific to the programme
};
HydrateModelWithCommonProperties(model, context, programmeFilter);
model.Gateways = context.Vehicle.ListGateways(programmeFilter);
// If we are copying to another gateway, we need to remove the source gateway from the list of available gateways
if (filter.Action == SpecialFeatureMappingAction.Copy)
{
model.Gateways = model.Gateways.Where(g => !(g.Name.Equals(featureMapping.Gateway, StringComparison.InvariantCultureIgnoreCase)));
}
if (!(featureMapping is EmptyFdpSpecialFeatureMapping))
{
featureMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == featureMapping.ProgrammeId.GetValueOrDefault());
}
model.SpecialFeatureMapping = featureMapping;
return(model);
}
private static async Task <SpecialFeatureMappingViewModel> GetFullAndPartialViewModelForFeatureMappings
(
IDataContext context,
SpecialFeatureMappingFilter filter
)
{
var baseModel = GetBaseModel(context);
var model = new SpecialFeatureMappingViewModel(baseModel)
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : int.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.SpecialFeatureMappings = await context.Vehicle.ListFdpSpecialFeatureMappings(filter);
model.TotalPages = model.SpecialFeatureMappings.TotalPages;
model.TotalRecords = model.SpecialFeatureMappings.TotalRecords;
model.TotalDisplayRecords = model.SpecialFeatureMappings.TotalDisplayRecords;
foreach (var featureMapping in model.SpecialFeatureMappings.CurrentPage)
{
featureMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == featureMapping.ProgrammeId.GetValueOrDefault());
}
return(model);
}
public PagedResults <FdpSpecialFeatureMapping> FdpSpecialFeatureMappingGetMany(SpecialFeatureMappingFilter filter)
{
PagedResults <FdpSpecialFeatureMapping> retVal = null;
using (IDbConnection conn = DbHelper.GetDBConnection())
{
try
{
var para = DynamicParameters.FromCDSId(CurrentCDSID);
var totalRecords = 0;
var totalDisplayRecords = 0;
if (!string.IsNullOrEmpty(filter.CarLine))
{
para.Add("@CarLine", filter.CarLine, DbType.String);
}
if (!string.IsNullOrEmpty(filter.ModelYear))
{
para.Add("@ModelYear", filter.ModelYear, DbType.String);
}
if (!string.IsNullOrEmpty(filter.Gateway))
{
para.Add("@Gateway", filter.Gateway, DbType.String);
}
if (filter.PageIndex.HasValue)
{
para.Add("@PageIndex", filter.PageIndex.Value, DbType.Int32);
}
if (filter.PageSize.HasValue)
{
para.Add("@PageSize", filter.PageSize.HasValue ? filter.PageSize.Value : 10, DbType.Int32);
}
if (filter.SortIndex.HasValue)
{
para.Add("@SortIndex", filter.SortIndex.Value, DbType.Int32);
}
if (filter.SortDirection != SortDirection.NotSet)
{
var direction = filter.SortDirection == SortDirection.Descending ? "DESC" : "ASC";
para.Add("@SortDirection", direction, DbType.String);
}
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);
var results = conn.Query <FdpSpecialFeatureMapping>("dbo.Fdp_SpecialFeatureMapping_GetMany", para, commandType: CommandType.StoredProcedure);
if (results.Any())
{
totalRecords = para.Get <int>("@TotalRecords");
totalDisplayRecords = para.Get <int>("@TotalDisplayRecords");
}
retVal = new PagedResults <FdpSpecialFeatureMapping>
{
PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
TotalRecords = totalRecords,
TotalDisplayRecords = totalDisplayRecords,
PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : totalRecords
};
var currentPage = new List <FdpSpecialFeatureMapping>();
foreach (var result in results)
{
currentPage.Add(result);
}
retVal.CurrentPage = currentPage;
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
return(retVal);
}
private async Task <SpecialFeatureMappingViewModel> GetModelFromParameters(SpecialFeatureMappingParameters parameters)
{
return(await SpecialFeatureMappingViewModel.GetModel(DataContext, SpecialFeatureMappingFilter.FromFeatureMappingParameters(parameters)));
}
public async Task <PagedResults <FdpSpecialFeatureMapping> > ListFdpSpecialFeatureMappings(SpecialFeatureMappingFilter filter)
{
return(await Task.FromResult(_featureDataStore.FdpSpecialFeatureMappingGetMany(filter)));
}
public async Task <FdpSpecialFeatureMapping> GetFdpSpecialFeatureMapping(SpecialFeatureMappingFilter filter)
{
return(await Task.FromResult(_featureDataStore.FdpSpecialFeatureMappingGet(filter)));
}
