public static async Task <FeatureMappingViewModel> GetModel(IDataContext context,
                                                                    FeatureMappingFilter filter)
        {
            FeatureMappingViewModel model;

            if (filter.Action == FeatureMappingAction.Delete ||
                filter.Action == FeatureMappingAction.Mapping ||
                filter.Action == FeatureMappingAction.Copy)
            {
                model = await GetFullAndPartialViewModelForFeatureMapping(context, filter);
            }
            else if (filter.Action == FeatureMappingAction.Mappings ||
                     filter.Action == FeatureMappingAction.CopyAll)
            {
                model = await GetFullAndPartialViewModelForFeatureMappings(context, filter);
            }
            else if (filter.Action == FeatureMappingAction.FeatureCodes)
            {
                model = await GetFullAndPartialViewModelForFeatureCodes(context, filter);
            }
            else
            {
                model = GetFullAndPartialViewModel(context, filter);
            }
            if (filter.Action != FeatureMappingAction.NotSet)
            {
                model.IdentifierPrefix = Enum.GetName(filter.Action.GetType(), filter.Action);
            }
            return(model);
        }
Esempio n. 2
0
        public FdpFeatureMapping FdpFeatureMappingGet(FeatureMappingFilter filter)
        {
            FdpFeatureMapping retVal = new EmptyFdpFeatureMapping();

            using (IDbConnection conn = DbHelper.GetDBConnection())
            {
                try
                {
                    var para = new DynamicParameters();
                    para.Add("@FdpFeatureMappingId", filter.FeatureMappingId.GetValueOrDefault(), DbType.Int32);

                    var results = conn.Query <FdpFeatureMapping>("Fdp_FeatureMapping_Get", para, commandType: CommandType.StoredProcedure);
                    if (results.Any())
                    {
                        retVal = results.First();
                    }
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                    throw;
                }
            }
            return(retVal);
        }
Esempio n. 3
0
        public async Task <ActionResult> ListFeatureCodes(FeatureMappingParameters parameters)
        {
            ValidateFeatureMappingParameters(parameters, FeatureMappingParametersValidator.NoValidation);

            var filter = new FeatureMappingFilter()
            {
                FilterMessage = parameters.FilterMessage,
                CarLine       = parameters.CarLine,
                ModelYear     = parameters.ModelYear,
                Gateway       = parameters.Gateway,
                Action        = FeatureMappingAction.FeatureCodes,
                DocumentId    = parameters.DocumentId
            };

            filter.InitialiseFromJson(parameters);

            var results = await FeatureMappingViewModel.GetModel(DataContext, filter);

            var jQueryResult = new JQueryDataTableResultModel(results);

            foreach (var result in results.OxoFeatures.CurrentPage)
            {
                try
                {
                    jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
            }
            return(Json(jQueryResult));
        }
Esempio n. 4
0
        public async Task <ActionResult> ModalContent(FeatureMappingParameters parameters)
        {
            ValidateFeatureMappingParameters(parameters, FeatureMappingParametersValidator.Action);

            var filter = FeatureMappingFilter.FromFeatureMappingParameters(parameters);
            var derivativeMappingView = await FeatureMappingViewModel.GetModel(DataContext, filter);

            return(PartialView(GetContentPartialViewName(parameters.Action), derivativeMappingView));
        }
Esempio n. 5
0
        public async Task <ActionResult> FeatureCodePage(FeatureMappingParameters parameters)
        {
            var filter = new FeatureMappingFilter()
            {
                PageIndex = PageIndex,
                PageSize  = PageSize
            };

            return(View(await FeatureMappingViewModel.GetModel(DataContext, filter)));
        }
        private static FeatureMappingViewModel GetFullAndPartialViewModel(IDataContext context,
                                                                          FeatureMappingFilter filter)
        {
            var model = new FeatureMappingViewModel(GetBaseModel(context))
            {
                Configuration = context.ConfigurationSettings,
            };

            HydrateModelWithCommonProperties(model, context);

            return(model);
        }
Esempio n. 7
0
        public async Task <ActionResult> ContextMenu(FeatureMappingParameters parameters)
        {
            ValidateFeatureMappingParameters(parameters, FeatureMappingParametersValidator.FeatureMappingIdentifier);

            var filter = FeatureMappingFilter.FromFeatureMappingParameters(parameters);

            filter.Action = FeatureMappingAction.Mapping;

            var derivativeMappingView = await FeatureMappingViewModel.GetModel(DataContext, filter);

            return(PartialView("_ContextMenu", derivativeMappingView));
        }
Esempio n. 8
0
        protected override bool IsValid(PropertyValidatorContext context)
        {
            Parameters = context.ParentContext.InstanceToValidate as FeatureMappingParameters;

            var filter = FeatureMappingFilter.FromFeatureMappingParameters(Parameters);

            filter.PageSize = int.MaxValue;

            var oxoFeatures =
                _context.Vehicle.ListOxoFeatures(filter).Result;

            return
                (!oxoFeatures.CurrentPage.Any(IsExistingFeatureCode));
        }
Esempio n. 9
0
        public PagedResults <OxoFeature> FdpOxoFeatureGetMany(FeatureMappingFilter filter)
        {
            var results = FdpFeatureMappingGetMany(filter);
            var page    = results.CurrentPage.Select(result => new OxoFeature(result)).ToList();

            return(new PagedResults <OxoFeature>
            {
                PageIndex = results.PageIndex,
                PageSize = results.PageSize,
                TotalDisplayRecords = results.TotalDisplayRecords,
                TotalFail = results.TotalFail,
                TotalRecords = results.TotalRecords,
                TotalSuccess = results.TotalSuccess,
                CurrentPage = page
            });
        }
        private static async Task <FeatureMappingViewModel> GetFullAndPartialViewModelForFeatureMapping
        (
            IDataContext context,
            FeatureMappingFilter filter
        )
        {
            var baseModel = GetBaseModel(context);
            var model     = new FeatureMappingViewModel()
            {
                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.GetFdpFeatureMapping(filter);

            var programmeFilter = new ProgrammeFilter()
            {
                ProgrammeId = featureMapping.ProgrammeId,
                Gateway     = featureMapping.Gateway,
                Code        = model.FeatureMapping.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 == FeatureMappingAction.Copy)
            {
                model.Gateways = model.Gateways.Where(g => !(g.Name.Equals(featureMapping.Gateway, StringComparison.InvariantCultureIgnoreCase)));
            }

            if (!(featureMapping is EmptyFdpFeatureMapping))
            {
                featureMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == featureMapping.ProgrammeId.GetValueOrDefault());
            }
            model.FeatureMapping = featureMapping;

            return(model);
        }
        private static async Task <FeatureMappingViewModel> GetFullAndPartialViewModelForFeatureCodes
        (
            IDataContext context,
            FeatureMappingFilter filter
        )
        {
            var baseModel = GetBaseModel(context);
            var model     = new FeatureMappingViewModel(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.OxoFeatures = await context.Vehicle.ListOxoFeatures(filter);

            model.TotalPages          = model.OxoFeatures.TotalPages;
            model.TotalRecords        = model.OxoFeatures.TotalRecords;
            model.TotalDisplayRecords = model.OxoFeatures.TotalDisplayRecords;

            foreach (var oxoFeature in model.OxoFeatures.CurrentPage)
            {
                oxoFeature.Programme = model.Programmes.FirstOrDefault(p => p.Id == oxoFeature.ProgrammeId.GetValueOrDefault());
                oxoFeature.Document  = oxoFeature.Document = model.Documents.FirstOrDefault(d => d.Id == oxoFeature.DocumentId);
            }

            return(model);
        }
Esempio n. 12
0
 private async Task <FeatureMappingViewModel> GetModelFromParameters(FeatureMappingParameters parameters)
 {
     return(await FeatureMappingViewModel.GetModel(DataContext, FeatureMappingFilter.FromFeatureMappingParameters(parameters)));
 }
Esempio n. 13
0
        public PagedResults <FdpFeatureMapping> FdpFeatureMappingGetMany(FeatureMappingFilter filter)
        {
            PagedResults <FdpFeatureMapping> 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);
                    }
                    para.Add("@DocumentId", filter.DocumentId, DbType.Int32);
                    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);
                    if (filter.IncludeAllFeatures)
                    {
                        para.Add("@IncludeAllFeatures", true, DbType.Boolean);
                    }
                    if (filter.OxoFeaturesOnly)
                    {
                        para.Add("@OxoFeaturesOnly", filter.OxoFeaturesOnly, DbType.Boolean);
                    }
                    if (!string.IsNullOrEmpty(filter.FilterMessage))
                    {
                        para.Add("@FilterMessage", filter.FilterMessage, DbType.String);
                    }

                    var results = conn.Query <FdpFeatureMapping>("dbo.Fdp_FeatureMapping_GetMany", para, commandType: CommandType.StoredProcedure);

                    if (results.Any())
                    {
                        totalRecords        = para.Get <int>("@TotalRecords");
                        totalDisplayRecords = para.Get <int>("@TotalDisplayRecords");
                    }
                    retVal = new PagedResults <FdpFeatureMapping>
                    {
                        PageIndex           = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
                        TotalRecords        = totalRecords,
                        TotalDisplayRecords = totalDisplayRecords,
                        PageSize            = filter.PageSize.HasValue ? filter.PageSize.Value : totalRecords
                    };

                    var currentPage = new List <FdpFeatureMapping>();

                    foreach (var result in results)
                    {
                        currentPage.Add(result);
                    }
                    retVal.CurrentPage = currentPage;
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                    throw;
                }
            }
            return(retVal);
        }
 public async Task <PagedResults <OxoFeature> > ListOxoFeatures(FeatureMappingFilter filter)
 {
     filter.IncludeAllFeatures = true;
     filter.OxoFeaturesOnly    = true;
     return(await Task.FromResult(_featureDataStore.FdpOxoFeatureGetMany(filter)));
 }
 public async Task <PagedResults <FdpFeatureMapping> > ListFdpFeatureMappings(FeatureMappingFilter filter)
 {
     return(await Task.FromResult(_featureDataStore.FdpFeatureMappingGetMany(filter)));
 }
 public async Task <FdpFeatureMapping> GetFdpFeatureMapping(FeatureMappingFilter filter)
 {
     return(await Task.FromResult(_featureDataStore.FdpFeatureMappingGet(filter)));
 }