private static async Task<TrimViewModel> GetFullAndPartialViewModelForTrim(IDataContext context,
                                                                                        TrimFilter filter)
 {
     var model = new TrimViewModel()
     {
         PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1,
         PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue,
         Configuration = context.ConfigurationSettings
     };
     var trim = await context.Vehicle.GetFdpTrim(filter);
     var programmeFilter = new ProgrammeFilter()
     {
         ProgrammeId = trim.ProgrammeId,
         Gateway = trim.Gateway
     };
     HydrateModelWithCommonProperties(model, context, programmeFilter);
     
     if (!(trim is EmptyFdpTrim))
     {
         trim.Programme = model.Programmes.FirstOrDefault(p => p.Id == trim.ProgrammeId);
     }
     model.Trim = trim;
    
     return model;
 }
        private static TrimViewModel GetFullAndPartialViewModel(IDataContext context,
                                                                      TrimFilter filter)
        {
            var model = new TrimViewModel(SharedModelBase.GetBaseModel(context))
            {
                Configuration = context.ConfigurationSettings,
            };
            HydrateModelWithCommonProperties(model, context);

            return model;
        }
        public IEnumerable<FdpTrimMapping> ModelTrimOxoTrimGetMany(TrimFilter filter)
        {
            filter.PageSize = 0;
            
            var trim = FdpTrimMappingGetMany(filter);
            if (trim == null || trim.CurrentPage == null || !trim.CurrentPage.Any())
            {
                return Enumerable.Empty<FdpTrimMapping>();
            }

            return trim.CurrentPage.Where(d => !d.FdpTrimMappingId.HasValue);
        }
        public static async Task<TrimViewModel> GetModel(IDataContext context, TrimFilter trimFilter)
        {
            TrimViewModel model = null;

            if (trimFilter.Action == TrimAction.Delete || trimFilter.Action == TrimAction.Trim)
            {
                model = await GetFullAndPartialViewModelForTrim(context, trimFilter);
            }
            else if (trimFilter.Action == TrimAction.TrimLevels)
            {
                model = await GetFullAndPartialViewModelForTrims(context, trimFilter);
            }
            else
            {
                model = GetFullAndPartialViewModel(context, trimFilter);
            }
            if (trimFilter.Action != TrimAction.NotSet)
            {
                model.IdentifierPrefix = Enum.GetName(trimFilter.Action.GetType(), trimFilter.Action);
            }
           
            return model;
        }
 public async Task<PagedResults<FdpTrim>> ListFdpTrims(TrimFilter filter)
 {
     return await Task.FromResult(_trimDataStore.FdpTrimGetMany(filter));
 }
 public async Task<FdpTrim> GetFdpTrim(TrimFilter filter)
 {
     return await Task.FromResult(_trimDataStore.FdpTrimGet(filter));
 }
 public IEnumerable<FdpTrimMapping> ListOxoTrim(TrimFilter filter)
 {
     filter.PageSize = 0;
     return _trimDataStore.ModelTrimOxoTrimGetMany(filter);
 }
 public IEnumerable<FdpTrimMapping> ListTrim(TrimFilter filter)
 {
     return _trimDataStore.ModelTrimGetMany(filter);
 }
        private static async Task<TrimViewModel> GetFullAndPartialViewModelForTrims(IDataContext context,
                                                                                                TrimFilter filter)
        {
            var baseModel = SharedModelBase.GetBaseModel(context);
            var model = new TrimViewModel()
            {
                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.Trims = await context.Vehicle.ListFdpTrims(filter);
            model.TotalPages = model.Trims.TotalPages;
            model.TotalRecords = model.Trims.TotalRecords;
            model.TotalDisplayRecords = model.Trims.TotalDisplayRecords;

            foreach (var trim in model.Trims.CurrentPage)
            {
                trim.Programme = model.Programmes.FirstOrDefault(p => p.Id == trim.ProgrammeId);
            }

            return model;
        }
        public PagedResults<FdpTrimMapping> FdpTrimMappingGetMany(TrimFilter filter)
        {
            PagedResults<FdpTrimMapping> 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 (!string.IsNullOrEmpty(filter.Dpck))
                    {
                        para.Add("@DPCK", filter.Dpck, DbType.String);
                    }
                    if (filter.IncludeAllTrim)
                    {
                        para.Add("@IncludeAllTrim", filter.IncludeAllTrim, DbType.Boolean);
                    }
                    if (filter.OxoTrimOnly)
                    {
                        para.Add("@OxoTrimOnly", filter.OxoTrimOnly, DbType.Boolean);
                    }
                    if (filter.IgnoreBMC)
                    {
                        para.Add("@IgnoreBMC", filter.IgnoreBMC, DbType.Boolean);
                    }
                    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<FdpTrimMapping>("dbo.Fdp_TrimMapping_GetMany", para, commandType: CommandType.StoredProcedure);

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

                    var currentPage = results.ToList();

                    retVal.CurrentPage = currentPage;
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                    throw;
                }
            }
            return retVal;
        }
        public PagedResults<FdpTrim> FdpTrimGetMany(TrimFilter filter)
        {
            PagedResults<FdpTrim> 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);
                    }
                    if (filter.ProgrammeId.HasValue)
                    {
                        para.Add("@ProgrammeId", filter.ProgrammeId, DbType.Int32);
                    }
                    if (!string.IsNullOrEmpty(filter.Gateway))
                    {
                        para.Add("@Gateway", filter.Gateway, 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<FdpTrim>("dbo.Fdp_Trim_GetMany", para, commandType: CommandType.StoredProcedure);

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

                    var currentPage = new List<FdpTrim>();

                    foreach (var result in results)
                    {
                        currentPage.Add(result);
                    }
                    retVal.CurrentPage = currentPage;
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                    throw;
                }
            }
            return retVal;
        }
 public FdpTrim FdpTrimGet(TrimFilter filter)
 {
     FdpTrim retVal = new EmptyFdpTrim();
     using (IDbConnection conn = DbHelper.GetDBConnection())
     {
         try
         {
             var para = new DynamicParameters();
             para.Add("@FdpTrimId", filter.TrimId.GetValueOrDefault(), DbType.Int32);
             retVal = conn.Query<FdpTrim>("dbo.Fdp_Trim_Get", para, commandType: CommandType.StoredProcedure).FirstOrDefault();
         }
         catch (Exception ex)
         {
             Log.Error(ex);
             throw;
         }
     }
     return retVal;
 }