예제 #1
0
        public static PaginationData GetInstance(SearchRequestDto searchDTO, EntityMetadata entityMetadata)
        {
            var            paginatedSearchRequestDto = searchDTO as PaginatedSearchRequestDto;
            PaginationData paginationData            = null;

            if (paginatedSearchRequestDto != null && paginatedSearchRequestDto.PageSize > 0 && paginatedSearchRequestDto.ShouldPaginate)
            {
                paginationData = new PaginationData(paginatedSearchRequestDto.PageSize,
                                                    paginatedSearchRequestDto.PageNumber, QuerySearchSortBuilder.BuildSearchSort(entityMetadata, searchDTO));
            }
            return(paginationData);
        }
예제 #2
0
        //needed because nhibernate paging is buggy
        public static string ApplyManualPaging(string queryst, PaginationData paginationData)
        {
            var pageSize        = paginationData.PageSize;
            var firstValue      = (paginationData.PageNumber - 1) * pageSize;
            var hasUnion        = queryst.Contains("union") || queryst.Contains("UNION");
            var templateToUse   = hasUnion ? ManualPaginationUnionTemplate : ManualPaginationTemplate;
            var pagingCondition = hasUnion ? "paging.rownum" : "rownum";
            var orderBy1        = paginationData.SortString;
            var orderBy         = orderBy1;

            if (!hasUnion)
            {
                //need to remove the select keyword here
                queryst = queryst.Substring("select".Length);
            }
            queryst = queryst.Replace(orderBy, "");
            var paginationCondition = pagingCondition + " <= " + pageSize;

            if (firstValue != 0)
            {
                paginationCondition = pagingCondition + " between " + (firstValue + 1) + " and " + (firstValue + pageSize);
            }
            return(templateToUse.Fmt(orderBy, queryst, paginationCondition));
        }
예제 #3
0
        public IList <dynamic> FindByNativeQuery(String queryst, ExpandoObject parameters, PaginationData paginationData = null, string queryAlias = null)
        {
            var before = Stopwatch.StartNew();

            using (var session = GetSessionManager().OpenSession()) {
                var query = BuildQuery(queryst, parameters, session, true, paginationData, queryAlias);
                query.SetResultTransformer(NhTransformers.ExpandoObject);
                var result = query.List <dynamic>();
                LogPaginationQuery(queryst, queryAlias, before, parameters);
                GetLog().Debug(LoggingUtil.BaseDurationMessageFormat(before, "{0}: done query".Fmt(queryAlias ?? "")));
                return(result);
            }
        }
예제 #4
0
        public IQuery BuildQuery(string queryst, ExpandoObject parameters, ISession session, bool native = false, PaginationData paginationData = null, string queryAlias = null)
        {
            LogQuery(queryst, queryAlias, parameters);
            if (paginationData != null && ApplicationConfiguration.IsDB2(ApplicationConfiguration.DBType.Maximo))
            {
                //nhibernate pagination breaks in some scenarios, at least in DB2, keeping others intact for now
                queryst = NHibernatePaginationUtil.ApplyManualPaging(queryst, paginationData);
            }
            //            LogPaginationQuery(queryst,queryAlias, parameters);

            var query = native ? session.CreateSQLQuery(queryst) : session.CreateQuery(queryst);

            query.SetTimeout(MetadataProvider.GlobalProperties.QueryTimeout());

            if (!ApplicationConfiguration.IsDB2(ApplicationConfiguration.DBType.Maximo) && paginationData != null)
            {
                var pageSize = paginationData.PageSize;
                query.SetMaxResults(pageSize);
                query.SetFirstResult((paginationData.PageNumber - 1) * pageSize);
            }
            if (parameters == null)
            {
                return(query);
            }
            foreach (var parameter in parameters)
            {
                if (parameter.Value.GetType().IsGenericType&& parameter.Value is IEnumerable)
                {
                    var list = new List <string>();
                    list.AddRange((IEnumerable <string>)parameter.Value);
                    if (query.NamedParameters.Contains(parameter.Key))
                    {
                        query.SetParameterList(parameter.Key, list);
                    }
                }
                else
                {
                    // TODO: This is wrong!!! The start and end date should be 2 diferent parameters. REFACTOR LATER!!!
                    if (parameter.Key.IndexOf("___") == -1)
                    {
                        if (query.NamedParameters.Contains(parameter.Key))
                        {
                            query.SetParameter(parameter.Key, parameter.Value);
                        }
                    }
                    else
                    {
                        var startDateString = parameter.Value.ToString().Split(new[] { "___" }, StringSplitOptions.RemoveEmptyEntries)[0];
                        var startDate       = DateUtil.Parse(startDateString);
                        var inMemoryUser    = SecurityFacade.CurrentUser();
                        if (startDate.HasValue)
                        {
                            startDate = startDate.Value.FromUserToRightKind(inMemoryUser);
                            if (!startDateString.Contains(":"))
                            {
                                startDate = DateUtil.BeginOfDay(startDate.Value);
                            }
                        }
                        var endDateString = parameter.Value.ToString().Split(new[] { "___" }, StringSplitOptions.RemoveEmptyEntries)[1];
                        var endDate       = DateUtil.Parse(endDateString);
                        if (endDate.HasValue)
                        {
                            endDate = endDate.Value.FromUserToRightKind(inMemoryUser);
                            if (!endDateString.Contains(":"))
                            {
                                endDate = DateUtil.BeginOfDay(endDate.Value);
                            }
                        }


                        query.SetParameter(parameter.Key + "_start", startDate);
                        query.SetParameter(parameter.Key + "_end", endDate);
                    }
                }
            }
            return(query);
        }