예제 #1
0
        public IDocumentQuery <Package> CreateCurrentInventoryQuery(IDocumentSession session,
                                                                    string communityCode,
                                                                    string sortBy,
                                                                    bool sortDescending,
                                                                    bool viewIsDeleted,
                                                                    DefconFilter defconFilter,
                                                                    string unitResidentFilter,
                                                                    int?take)
        {
            IDocumentQuery <Package> query = session.Advanced.LuceneQuery <Package>("Package/CurrentInventory").Take(take.Value);

            query.WhereEquals("CommunityCode", communityCode);
            query.AndAlso().Not.WhereEquals("Status", PackageStatusCodes.Released);

            if (!viewIsDeleted)
            {
                query.AndAlso();
                query.WhereEquals("IsDeleted", false);
            }

            DefConFilterQuery(query, defconFilter);

            if (!string.IsNullOrEmpty(unitResidentFilter))
            {
                query.AndAlso();
                query.WhereEquals("AddressName", unitResidentFilter);
            }

            if (!string.IsNullOrEmpty((sortBy)))
            {
                query.AddOrder(sortBy, sortDescending);
            }
            return(query);
        }
예제 #2
0
        private void VisitAndAlso(BinaryExpression andAlso)
        {
            VisitExpression(andAlso.Left);

            luceneQuery.AndAlso();

            VisitExpression(andAlso.Right);
        }
예제 #3
0
        private static void DefConFilterQuery <T>(IDocumentQuery <T> query, DefconFilter defconFilter)
        {
            if (defconFilter == null || (defconFilter.Start == null && defconFilter.End == null))
            {
                return;
            }

            DateTime?startDate = null;
            DateTime?endDate   = null;

            if (defconFilter.Start.HasValue)
            {
                startDate = DateTime.Today.Date.AddDays(-(defconFilter.Start.Value));
            }

            if (defconFilter.End.HasValue)
            {
                endDate = DateTime.Today.Date.AddDays(-(defconFilter.End.Value));
            }

            query.AndAlso();
            if (startDate.HasValue && endDate.HasValue)
            {
                query.WhereBetweenOrEqual("ReceiveDate", startDate.Value, endDate.Value.AddDays(1));
            }
            else if (!startDate.HasValue)
            {
                query.WhereLessThanOrEqual("ReceiveDate", endDate.Value.AddDays(1));
            }
        }
        private void VisitAndAlso(BinaryExpression andAlso)
        {
            if (subClauseDepth > 0)
            {
                luceneQuery.OpenSubclause();
            }
            subClauseDepth++;

            VisitExpression(andAlso.Left);
            luceneQuery.AndAlso();
            VisitExpression(andAlso.Right);

            subClauseDepth--;
            if (subClauseDepth > 0)
            {
                luceneQuery.CloseSubclause();
            }
        }
예제 #5
0
        public static IDocumentQuery <T> FilterByQueueAddress <T>(this IDocumentQuery <T> source, Request request)
        {
            string queueAddress = null;

            if ((bool)request.Query.queueaddress.HasValue)
            {
                queueAddress = (string)request.Query.queueaddress;
            }

            if (string.IsNullOrWhiteSpace(queueAddress))
            {
                return(source);
            }

            source.AndAlso();
            source.WhereEquals("QueueAddress", queueAddress.ToLowerInvariant());

            return(source);
        }
예제 #6
0
        public static IDocumentQuery <T> FilterByLastModifiedRange <T>(this IDocumentQuery <T> source, Request request)
        {
            string modified = null;

            if ((bool)request.Query.modified.HasValue)
            {
                modified = (string)request.Query.modified;
            }

            if (modified == null)
            {
                return(source);
            }

            var filters = modified.Split(new[]
            {
                "..."
            }, StringSplitOptions.None);

            if (filters.Length != 2)
            {
                throw new Exception("Invalid modified date range, dates need to be in ISO8601 format and it needs to be a range eg. 2016-03-11T00:27:15.474Z...2016-03-16T03:27:15.474Z");
            }
            try
            {
                var from = DateTime.Parse(filters[0], CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
                var to   = DateTime.Parse(filters[1], CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);

                source.AndAlso();
                source.WhereBetweenOrEqual("LastModified", from.Ticks, to.Ticks);
            }
            catch (Exception)
            {
                throw new Exception("Invalid modified date range, dates need to be in ISO8601 format and it needs to be a range eg. 2016-03-11T00:27:15.474Z...2016-03-16T03:27:15.474Z");
            }

            return(source);
        }
예제 #7
0
        public static IDocumentQuery <T> FilterByStatusWhere <T>(this IDocumentQuery <T> source, Request request)
        {
            string status = null;

            if ((bool)request.Query.status.HasValue)
            {
                status = (string)request.Query.status;
            }

            if (status == null)
            {
                return(source);
            }

            var filters  = status.Replace(" ", String.Empty).Split(',');
            var excludes = new List <int>();
            var includes = new List <int>();

            foreach (var filter in filters)
            {
                FailedMessageStatus failedMessageStatus;

                if (filter.StartsWith("-"))
                {
                    if (Enum.TryParse(filter.Substring(1), true, out failedMessageStatus))
                    {
                        excludes.Add((int)failedMessageStatus);
                    }
                    continue;
                }

                if (Enum.TryParse(filter, true, out failedMessageStatus))
                {
                    includes.Add((int)failedMessageStatus);
                }
            }

            var sb = new StringBuilder();

            sb.Append("((");
            if (includes.Count == 0)
            {
                sb.Append("*");
            }
            else
            {
                sb.Append(String.Join(" OR ", includes.ToArray()));
            }
            sb.Append(")");

            if (excludes.Count > 0)
            {
                sb.Append(" AND NOT (");
                sb.Append(String.Join(" OR ", excludes.ToArray()));
                sb.Append(")");
            }
            sb.Append(")");

            source.AndAlso();
            source.Where($"Status: {sb}");

            return(source);
        }