예제 #1
0
        /// <summary>
        /// Gets list object of the table CompanyApplication.
        /// </summary>
        /// <param name="paginationDto">Attributes to apply the pagination.</param>
        /// <param name="listCompanyApplicationDto">List that contains the DTOs from CompanyApplication table that filter the query.</param>
        /// <returns>List object of the table CompanyApplication.</returns>
        /// <author>Mauricio Suarez.</author>
        private List <CompanyApplicationDto> ExecutePaginated(PaginationDto paginationDto, List <CompanyApplicationDto> listCompanyApplicationDto)
        {
            using (SecurityManagmentEntities context = new SecurityManagmentEntities())
            {
                if (string.IsNullOrEmpty(paginationDto.SortExpression))
                {
                    paginationDto.SortExpression = "IdCompanyApplication";
                    paginationDto.SortDirection  = "ASC";
                }

                if (paginationDto.PageSize == 0 && paginationDto.CurrentPage == 0)
                {
                    paginationDto.PageSize = int.MaxValue;
                }

                var predicate = ConditionalQuery.GeneratePredicateQuery <CompanyApplication, CompanyApplicationDto>(listCompanyApplicationDto);

                return(context.CompanyApplication.AsExpandable()
                       .Include(ConditionalQuery.GenerateIncludes(listCompanyApplicationDto))
                       .Where(predicate).AsParallel()
                       .OrderBy(paginationDto.SortExpression + " " + paginationDto.SortDirection)
                       .Skip(paginationDto.CurrentPage * paginationDto.PageSize)
                       .Take(paginationDto.PageSize)
                       .Select(Mapper.Map <CompanyApplication, CompanyApplicationDto>).ToList());
            }
        }
예제 #2
0
        /// <summary>
        /// Gets list object of the table Application.
        /// </summary>
        /// <param name="listFilterGeneric">List that contains the DTOs from Application table that filter the query.</param>
        /// <returns>List object of the table Application.</returns>
        /// <author>Mauricio Suárez.</author>
        private List <ApplicationDto> ExecuteUnPaginated(List <ApplicationDto> listApplicationDto)
        {
            using (SecurityManagmentEntities context = new SecurityManagmentEntities())//GetDataBaseContext())
            {
                var predicate = ConditionalQuery.GeneratePredicateQuery <Application, ApplicationDto>(listApplicationDto);

                return(context.Application.AsExpandable()
                       .Include(ConditionalQuery.GenerateIncludes(listApplicationDto))
                       .Where(predicate).AsParallel()
                       .Select(Mapper.Map <Application, ApplicationDto>).ToList());
            }
        }
        public List <NotificationsSettingsDto> GetUpdateNotifications(List <NotificationsSettingsDto> listFilterNotificationsSettings, bool summaryView)
        {
            using (SecurityManagmentEntities context = new SecurityManagmentEntities())//GetDataBaseContext())
            {
                List <ObjectParameter> parameters = new List <ObjectParameter> {
                    new ObjectParameter("StartDate", new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second))
                };

                parameters.AddRange(ConditionalQuery.GenerateParametersConditionalQuery(listFilterNotificationsSettings));
                string filterDate = (summaryView ? "SummaryEndDate" : "DashboardEndDate");

                return(context.NotificationsSettings
                       .Include(ConditionalQuery.GenerateIncludes(listFilterNotificationsSettings))
                       .Where("(" + ConditionalQuery.GenerateConditionalQuery(listFilterNotificationsSettings) + ") AND it." + filterDate + " >= @StartDate", parameters.ToArray()).AsParallel()
                       .Select(Mapper.Map <NotificationsSettings, NotificationsSettingsDto>).ToList());
            }
        }
예제 #4
0
        /// <summary>
        /// Gets list object of the table Application.
        /// </summary>
        /// <param name="paginationDto">Attributes to apply the pagination.</param>
        /// <param name="listFilterGeneric">List that contains the DTOs from Application table that filter the query.</param>
        /// <returns>List object of the table Application.</returns>
        /// <author>Mauricio Suárez.</author>
        private List <ApplicationDto> ExecutePaginated(PaginationDto paginationDto, List <ApplicationDto> listApplicationDto)
        {
            using (SecurityManagmentEntities context = new SecurityManagmentEntities())//GetDataBaseContext())
            {
                int skipRol = paginationDto.Skip;

                if (string.IsNullOrEmpty(paginationDto.SortExpression))
                {
                    paginationDto.SortExpression = "IdApplication";
                    //paginationDto.SortDirection = SortDirection.Ascending.ToString();
                }

                return(context.Application
                       .Include(ConditionalQuery.GenerateIncludes(listApplicationDto))
                       .Where(ConditionalQuery.GenerateConditionalQuery(listApplicationDto), ConditionalQuery.GenerateParametersConditionalQuery(listApplicationDto)).AsParallel()
                       .AsQueryable()
                       .OrderBy(paginationDto.SortExpression + " " + paginationDto.SortDirectionAbbreviation)
                       .Skip(skipRol)
                       .Take(paginationDto.PageSize)
                       .Select(Mapper.Map <Application, ApplicationDto>).ToList());
            }
        }
예제 #5
0
        public List <ApplicationDto> GetApplicationByUser(List <ApplicationUserRoleDto> listApplicationUserRoleDto)
        {
            using (SecurityManagmentEntities context = new SecurityManagmentEntities())//GetDataBaseContext())
            {
                var predicate = ConditionalQuery.GeneratePredicateQuery <ApplicationUserRole, ApplicationUserRoleDto>(listApplicationUserRoleDto);

                return((List <ApplicationDto>)UtilitiesObject.RemoveOtherObjects(context.ApplicationUserRole
                                                                                 .Include(ConditionalQuery.GenerateIncludes(listApplicationUserRoleDto)).AsExpandable()
                                                                                 .Where(predicate).AsParallel()
                                                                                 .Select(data => data.ApplicationRole.Application)
                                                                                 .Distinct()
                                                                                 .Select(Mapper.Map <Application, ApplicationDto>).ToList()));
            }
        }