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;
        }
        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;
        }
 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));
 }
        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;
        }
        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;
        }
        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;
        }