/// <summary>
        /// Create a new instance.
        /// </summary>
        /// <param name="entryCriteria">The <see cref="EntryCriteria"/> used for the search.</param>
        /// <param name="resultOrder">The order of the results.</param>
        public EntrySearchCacheKey(EntryCriteria entryCriteria, ListOrder resultOrder)
        {
            Assert.ArgumentNotNull(entryCriteria, nameof(entryCriteria));

            EntryCriteria = entryCriteria;
            ResultOrder   = resultOrder;
        }
示例#2
0
        public async void GetLateHouse(bool Latehouse)
        {
            ListItemValLate          = new List <ListOrder>();
            popupPriviewsTickietView = false;
            var TransactionNumberVal = await new loginPageService().GetDetailByUrl(BetEntry.GetTrancationNumber + GlobalConstant.iPanelUserID);

            if (TransactionNumberVal.Status == 1)
            {
                LastTransactionNo = TransactionNumberVal.Response.ToString();
            }

            SB = "S";
            // var UserDetail = await new loginPageService().GetDetailByUrl(BetEntry.GetHouseDetail);
            var UserDetail = await new loginPageService().GetDetailByUrl((Latehouse == false ? BetEntry.GetEarlyHouseForTab : BetEntry.GetLateHouseForTab));

            if (UserDetail.Status == 1)
            {
                var wrShiipinglistVal = JsonConvert.DeserializeObject <List <vw_HousesDetails> >(UserDetail.Response.ToString());
                for (int i = 0; i < wrShiipinglistVal.Count; i++)
                {
                    Model = new ListOrder();
                    try
                    {
                        Model.Late1      = wrShiipinglistVal[i].HouseName;
                        Model.chkLate1   = false;
                        Model.Late1Id    = wrShiipinglistVal[i].HouseID;
                        Model.Latehouse1 = Latehouse;
                        i++;
                    }
                    catch { }
                    try
                    {
                        Model.Late2      = wrShiipinglistVal[i].HouseName;
                        Model.chkLate2   = false;
                        Model.Late2Id    = wrShiipinglistVal[i].HouseID;
                        Model.Latehouse2 = true;
                        i++;
                    }
                    catch { }
                    try
                    {
                        Model.Late3      = wrShiipinglistVal[i].HouseName;
                        Model.chkLate3   = false;
                        Model.Late3Id    = wrShiipinglistVal[i].HouseID;
                        Model.Latehouse3 = true;
                        i++;
                    }
                    catch { }
                    try
                    {
                        Model.Late4      = wrShiipinglistVal[i].HouseName;
                        Model.chkLate4   = false;
                        Model.Late4Id    = wrShiipinglistVal[i].HouseID;
                        Model.Latehouse4 = true;
                    }
                    catch { }
                    ListItemValLate.Add(Model);
                }
            }
        }
示例#3
0
        private void button1_Click(object sender, EventArgs e)
        {
            _orderList.Clear();
            _orderList = ListOrder.ShowOrders(dateFrom.SelectionStart, dateTo.SelectionStart);

            OnRewriteListBox();
        }
示例#4
0
        /// <summary>
        /// 将对象转换为其 XML 表示形式。
        /// </summary>
        /// <param name="writer">对象要序列化为的 <see cref="T:System.Xml.XmlWriter" /> 流。</param>
        public void WriteXml(XmlWriter writer)
        {
            writer.WriteElementString("FileName", FileName);
            writer.WriteElementString("FullName", FullName);
            writer.WriteElementString("Name", Name);
            writer.WriteElementString("Title", Title);
            writer.WriteElementString("Description", Description);
            writer.WriteElementString("Version", Version == null ? string.Empty : Version.ToString());
            writer.WriteElementString("IsExtend", IsExtend.ToString().ToLower());
            writer.WriteElementString("DisableStopAndUninstalled", DisableStopAndUninstalled.ToString().ToLower());
            writer.WriteElementString("ListOrder", ListOrder.ToString());
            writer.WriteElementString("State", State.ToString());
            writer.WriteStartElement("Reference");
            if (Reference != null)
            {
                Reference.ForEach(reference => { writer.WriteElementString("Assembly", reference); });
            }

            writer.WriteEndElement();
            writer.WriteStartElement("AbstractModules");
            if (AbstractModules != null)
            {
                AbstractModules.ForEach(module =>
                {
                    var namespaces = new XmlSerializerNamespaces();
                    namespaces.Add(string.Empty, string.Empty);
                    var xmlSerializer = new XmlSerializer(module.GetType());
                    xmlSerializer.Serialize(writer, module, namespaces);
                });
            }

            writer.WriteEndElement();
        }
示例#5
0
        /// <summary>
        /// Gets the list of entries for the specified <see cref="EntryCriteria"/>.
        /// </summary>
        /// <param name="criteria">The criteria used to search for the entries.</param>
        /// <param name="resultOrder">The ordering of the results.</param>
        /// <returns>The list of entries for the criteria, or null if the criteria has not been cached.</returns>
        public SearchResults <Entry> Get(EntryCriteria criteria, ListOrder resultOrder)
        {
            Assert.ArgumentNotNull(criteria, nameof(criteria));

            var key = new EntrySearchCacheKey(criteria, resultOrder);

            return((SearchResults <Entry>)_cache.GetValue(key));
        }
        private async void DeleteOrder(int?obj)
        {
            try
            {
                dc = new DialogContent()
                {
                    Content = "Bạn muốn xóa hóa đơn này ?", Tilte = "Thông Báo"
                };
                var dialogYS = new DialogYesNo()
                {
                    DataContext = dc
                };
                var result = (bool)await DialogHost.Show(dialogYS, DialogHostId);

                if (result)
                {
                    if (await oh_repo.Remove((int)obj))
                    {
                        dc = new DialogContent()
                        {
                            Content = "Xóa Thành Công", Tilte = "Thông Báo"
                        };
                        dialog = new DialogOk()
                        {
                            DataContext = dc
                        };
                        DialogHost.CloseDialogCommand.Execute(null, null);
                        await DialogHost.Show(dialog, DialogHostId);

                        ListOrder.Remove(ListOrder.SingleOrDefault(t => t.PurID == (int)obj));
                    }
                    else
                    {
                        dc = new DialogContent()
                        {
                            Content = "Xóa Thất Bại", Tilte = "Thông Báo"
                        };
                        dialog = new DialogOk()
                        {
                            DataContext = dc
                        };
                        DialogHost.CloseDialogCommand.Execute(null, null);
                        await DialogHost.Show(dialog, DialogHostId);
                    }
                }
            }
            catch
            {
                dc.Content = "Có Lỗi";
                dc.Tilte   = "Thông Báo";
                dialog     = new DialogOk()
                {
                    DataContext = dc
                };
                DialogHost.CloseDialogCommand.Execute(null, null);
                await DialogHost.Show(dialog, DialogHostId);
            }
        }
示例#7
0
        /// <summary>
        /// Sets the list of entries for the specified <see cref="EntryCriteria"/>.
        /// </summary>
        /// <param name="criteria">The criteria used to search for the entries.</param>
        /// <param name="resultOrder">The ordering of the results.</param>
        /// <param name="entries">The entries for the search criteria.</param>
        public void Set(EntryCriteria criteria, ListOrder resultOrder, SearchResults <Entry> entries)
        {
            Assert.ArgumentNotNull(criteria, nameof(criteria));
            Assert.ArgumentNotNull(entries, nameof(entries));

            var key = new EntrySearchCacheKey(criteria, resultOrder);

            _cache.Add(key, entries);
        }
        public List <Product> GetProductList(string currencyName, ListOrder order, bool desc)
        {
            if (CurrencyManager.Exchange(currencyName, 1.0d) == null)
            {
                // Currency is not exist
                return(null);
            }

            var query = lawnmowerRepo.GetAll().Select(x => new Product()
            {
                Id    = x.Id,
                Price = (double)CurrencyManager.Exchange(currencyName, x.Price),
                Name  = x.Name,
                Type  = "Lawnmower"
            })
                        .Union(
                phonecaseRepo.GetAll().Select(x => new Product()
            {
                Id    = x.Id,
                Price = (double)CurrencyManager.Exchange(currencyName, x.Price),
                Name  = x.Name,
                Type  = "Phone Case"
            }))
                        .Union(
                tshirtRepo.GetAll().Select(x => new Product()
            {
                Id    = x.Id,
                Price = (double)CurrencyManager.Exchange(currencyName, x.Price),
                Name  = x.Name,
                Type  = "T-Shirt"
            })
                );

            switch (order)
            {
            case ListOrder.Id:
                return(desc ? query.OrderByDescending(x => x.Id).ToList()
                        : query.OrderBy(x => x.Id).ToList());

            case ListOrder.Name:
                return(desc ? query.OrderByDescending(x => x.Name).ToList()
                        : query.OrderBy(x => x.Name).ToList());

            case ListOrder.Price:
                return(desc ? query.OrderByDescending(x => x.Price).ToList()
                        : query.OrderBy(x => x.Price).ToList());

            case ListOrder.Type:
                return(desc ? query.OrderByDescending(x => x.Type).ToList()
                        : query.OrderBy(x => x.Type).ToList());

            default:
                return(query.ToList());
            }
        }
示例#9
0
        /// <summary>
        /// Create list create operation.
        /// Server creates list at given context level. The context is allowed to be beyond list
        /// boundaries only if pad is set to true.  In that case, nil list entries will be inserted to
        /// satisfy the context position.
        /// </summary>
        public static Operation Create(string binName, ListOrder order, bool pad, params CTX[] ctx)
        {
            // If context not defined, the set order for top-level bin list.
            if (ctx == null || ctx.Length == 0)
            {
                return(SetOrder(binName, order));
            }

            Packer packer = new Packer();

            CDT.Init(packer, ctx, SET_TYPE, 1, CTX.GetFlag(order, pad));
            packer.PackNumber((int)order);
            return(new Operation(Operation.Type.CDT_MODIFY, binName, Value.Get(packer.ToByteArray())));
        }
        public String listAppointments(ListOrder order)
        {
            // call locally to show a list of all apointments

            String response = "";
            int    counter  = 0;

            if (order == ListOrder.SEQUENCE)
            {
                response += "__________<< Sequential  Order >>__________" + "\n";
                foreach (Appointment appointment in appointmentsList)
                {
                    response += appointment.ToString() + "\n";
                    response += "___________________________________________" + "\n";
                    counter++;
                }
            }
            else
            {
                List <Appointment> copyOfAppointmentsList = this.appointmentsList.GetRange(0, this.appointmentsList.Count);
                copyOfAppointmentsList.Sort(
                    delegate(Appointment appointment1, Appointment appointment2)
                {
                    return(appointment1.CompareTo(appointment2));
                }
                    );

                response += "_____________<< Date  Order >>_____________" + "\n";
                int rowNum = 1;
                foreach (Appointment appointment in copyOfAppointmentsList)
                {
                    response += appointment.toString(rowNum++) + "\n";
                    response += "___________________________________________" + "\n";
                    counter++;
                }
            }
            if (counter == 0)
            {
                response += "No appointment has been added to the system. " + "\n";
            }
            else if (counter == 1)
            {
                response += "  " + counter + " appointment has been listed in the above table. " + "\n";
            }
            else
            {
                response += "  " + counter + " appointments have been listed in the above table. " + "\n";
            }
            return(response);
        }
示例#11
0
 void OnRewriteListBox()
 {
     button2.Enabled = false;
     listBox1.Items.Clear();
     foreach (Order_v2 o in _orderList)
     {
         //string s = string.Format("{0}:{1}:{2} >{3}", o.date.ToString(), o.ID, o.number, o.estr);
         string s = string.Format("{0}:{1}:{2} >{3}", o.date.ToString(Form1.DATE_FORMAT), o.GiveOrder, o.ForePerson, o.estr);
         listBox1.Items.Add(s);
     }
     label6.Text = ListOrder.listOrder.Count.ToString();
     label7.Text = _orderList.Count.ToString();
     //int i=0;
     //foreach (Order_v2 o in ListOrder.listOrder)
     //if (o.number == 0) i++;
     label8.Text = ListOrder.NotVerifydOrderList().Count.ToString();
 }
示例#12
0
        public ActionResult BulkOrder(int business_id, int personal_id, string time)
        {
            string        myid   = User.Identity.GetUserId();
            ActiveProfile active = db.activeprofiles.ToList()
                                   .Where(x => x.ApplicationUserId == myid).FirstOrDefault();

            PersonalAccount customer = db.personalaccounts.ToList().Where(x => x.ID == personal_id).FirstOrDefault();

            ListOrder listorder = db.listorders.ToList()
                                  .Where(x => x.BusinessID == business_id && x.PersonalAccID == personal_id && x.Date.TimeOfDay.ToString().Substring(0, 5) == time)
                                  .FirstOrDefault();
            List <ProductListOrder> productorder = db.productlistorders.ToList()
                                                   .Where(x => x.ListOrderID == listorder.ID).ToList();

            List <Order> orders      = new List <Order>();
            double       total       = 0;
            bool         im_business = false;

            foreach (ProductListOrder p in productorder)
            {
                Order order = db.orders.ToList().Where(x => x.ID == p.OrderID).FirstOrDefault();
                if (order != null)
                {
                    orders.Add(order);
                    total += order.Price * order.Qauntity;
                }
            }

            if (listorder.BusinessID == active.ActiveProfileID)
            {
                im_business = true;
            }
            if (listorder.BusinessID == active.ActiveProfileID && listorder.Status == "Pending")
            {
                listorder.Status = "Seen";
                db.SaveChanges();
            }
            ViewBag.ImBusiness   = im_business;
            ViewBag.OrderID      = listorder.ID;
            ViewBag.Status       = listorder.Status;
            ViewBag.Total        = total;
            ViewBag.PersonalID   = personal_id;
            ViewBag.CustomerName = customer.Names + " " + customer.Surname;

            return(View(orders));
        }
        private async void Addsuccess(PurchasingHeader obj)
        {
            try
            {
                if (obj != null)
                {
                    var newobj = await oh_repo.GetById(obj.PurID);

                    ListOrder.Add(newobj);
                    dc = new DialogContent()
                    {
                        Content = "Thêm Thành Công", Tilte = "Thông Báo"
                    };
                    dialog = new DialogOk()
                    {
                        DataContext = dc
                    };
                    DialogHost.CloseDialogCommand.Execute(null, null);
                    await DialogHost.Show(dialog, DialogHostId);
                }
                else
                {
                    dc = new DialogContent()
                    {
                        Content = "Thêm Thất Bại", Tilte = "Thông Báo"
                    };
                    dialog = new DialogOk()
                    {
                        DataContext = dc
                    };
                    DialogHost.CloseDialogCommand.Execute(null, null);
                    await DialogHost.Show(dialog, DialogHostId);
                }
            }
            catch
            {
                dc.Content = "Có Lỗi";
                dc.Tilte   = "Thông Báo";
                dialog     = new DialogOk()
                {
                    DataContext = dc
                };
                DialogHost.CloseDialogCommand.Execute(null, null);
                await DialogHost.Show(dialog, DialogHostId);
            }
        }
示例#14
0
        public void UpdateOrders()
        {
            ListOrdersResponse listOrdersResponse = client.ListOrders();

            if (listOrdersResponse.Result == 1 && listOrdersResponse.Orders.Count > 0)
            {
                List <Order> unshippedOrders = OrderService.GetOrders(StatusID: (int)Beasts.Model.Status.Processing).ToList();
                foreach (Order order in unshippedOrders)
                {
                    try
                    {
                        ListOrder listOrder = listOrdersResponse.Orders.Where(x => x.OrderId == order.PrintAuraID).FirstOrDefault();

                        if (listOrder != null)
                        {
                            if (listOrder.Status == Labs.PrintAura.Models.Status.Shipped)
                            {
                                var item = listOrder.Items.First();

                                Shipment shipment = new Shipment();
                                shipment.Tracking = item.Tracking;
                                shipment.ShipDate = item.ShippedDate.ToDateTime();
                                shipment.Service  = "USPS";
                                shipment.OrderID  = order.OrderID;

                                ShipmentService.CreateShipment(shipment);

                                order.Status = Beasts.Model.Status.Shipped;

                                OrderService.UpdateOrder(order);

                                Email.SendTracking(OrderService.GetOrders(order.OrderID).FirstOrDefault());
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        ExceptionService.CreateException(ex);
                    }
                }
            }
        }
示例#15
0
        public static List <ListOrder> ServiceProvider(int Id)
        {
            List <ListOrder> listOrders = new List <ListOrder>();
            ServicesContext  db         = new ServicesContext();
            var SPId = db.ServiceProviders.Where(g => g.UserId == Id).Select(g => g.Id).FirstOrDefault();
            var res  = from a in db.Orders
                       where SPId == a.ToFK
                       select a;

            foreach (var b in res)
            {
                ListOrder OrderObj = new ListOrder {
                    Id           = b.Id,
                    FromFK       = b.FromFK,
                    Status       = b.Status,
                    Date         = b.Date,
                    ScheduleDate = b.ScheduleDate
                };
                listOrders.Add(OrderObj);
            }
            return(listOrders);
        }
示例#16
0
        private BindableCollection <Order> Get_AllOrder(int curr, int record1page)
        {
            ListOrder.Clear();

            sql = $"SELECT * FROM ORDERS ORDER BY IDORDER OFFSET  { curr} ROWS FETCH NEXT  { record1page} ROWS ONLY";
            DataTable dt = Connection.GetALL_Data(sql);

            foreach (DataRow row in dt.Rows)
            {
                Order order = new Order();
                order.IdOrder      = row["IDORDER"].ToString();
                order.CustomerName = row["CUSTOMERNAME"].ToString();
                order.Address      = row["ADDRESS"].ToString();
                order.Email        = row["EMAIL"].ToString();
                order.Note         = row["NOTE"].ToString();
                order.Total        = row["TOTAL"].ToString();
                order.Status       = row["STATUS"].ToString();
                order.Date         = row["DATE"].ToString();
                ListOrder.Add(order);
            }
            return(ListOrder);
        }
示例#17
0
        public static List <ListOrder> PreviousOrder(int orderId)
        {
            List <ListOrder> a  = new List <ListOrder>();
            ServicesContext  db = new ServicesContext();
            var res             = from d in db.Orders
                                  where d.Id == orderId
                                  select d;

            foreach (var b in res)
            {
                ListOrder o = new ListOrder();
                if (o.Status == "Completed")
                {
                    o.Id           = b.Id;
                    o.FromFK       = b.FromFK;
                    o.Status       = b.Status;
                    o.Date         = b.Date;
                    o.ScheduleDate = b.ScheduleDate;
                    a.Add(o);
                }
            }
            return(a);
        }
示例#18
0
        /// <summary>
        /// Gets blog entries for the given blog which meet the criteria.
        /// </summary>
        /// <param name="blogRootItem">The root item of the blog to retrieve the entries for.</param>
        /// <param name="criteria">The criteria the entries should meet.</param>
        /// <param name="resultOrder">The ordering of the results.</param>
        /// <returns>The entries matching the criteria.</returns>
        public virtual SearchResults <Entry> GetBlogEntries(Item blogRootItem, EntryCriteria criteria, ListOrder resultOrder)
        {
            if (blogRootItem == null || criteria == null || criteria.PageNumber <= 0 || criteria.PageSize <= 0)
            {
                return(SearchResults <Entry> .Empty);
            }

            var cachedEntries = EntryCache?.Get(criteria, resultOrder);

            if (cachedEntries != null)
            {
                return(cachedEntries);
            }

            var customBlogItem = (from templateId in Settings.BlogTemplateIds
                                  where TemplateManager.TemplateIsOrBasedOn(blogRootItem, templateId)
                                  select(BlogHomeItem) blogRootItem).FirstOrDefault();

            if (customBlogItem == null)
            {
                customBlogItem = (from templateId in Settings.BlogTemplateIds
                                  let item = blogRootItem.FindAncestorByTemplate(templateId, TemplateManager)
                                             where item != null
                                             select(BlogHomeItem) item).FirstOrDefault();
            }

            if (customBlogItem == null)
            {
                return(SearchResults <Entry> .Empty);
            }

            var blogSettings = BlogSettingsResolver.Resolve(customBlogItem);

            using (var context = CreateSearchContext(blogRootItem))
            {
                var builder = PredicateBuilder.Create <EntryResultItem>(searchItem =>
                                                                        searchItem.TemplateId == blogSettings.EntryTemplateID &&
                                                                        searchItem.Paths.Contains(customBlogItem.ID) &&
                                                                        searchItem.Language.Equals(customBlogItem.InnerItem.Language.Name, StringComparison.InvariantCulture)
                                                                        );

                // Tag
                if (!string.IsNullOrEmpty(criteria.Tag))
                {
                    builder = builder.And(i => i.Tags.Contains(criteria.Tag));
                }

                // Categories
                if (!string.IsNullOrEmpty(criteria.Category))
                {
                    var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(customBlogItem, criteria.Category);

                    // If the category is unknown, don't return any results.
                    if (categoryItem == null)
                    {
                        return(SearchResults <Entry> .Empty);
                    }

                    builder = builder.And(i => i.Category.Contains(categoryItem.ID));
                }

                if (criteria.MinimumDate != null)
                {
                    builder = builder.And(i => i.EntryDate >= criteria.MinimumDate);
                }

                if (criteria.MaximumDate != null)
                {
                    builder = builder.And(i => i.EntryDate <= criteria.MaximumDate);
                }

                var indexresults = context.GetQueryable <EntryResultItem>().Where(builder);

                if (resultOrder == ListOrder.Descending)
                {
                    indexresults = indexresults.OrderByDescending(item => item.EntryDate)
                                   .ThenByDescending(item => item.CreatedDate)
                                   .ThenByDescending(item => item.Title);
                }
                else
                {
                    indexresults = indexresults.OrderBy(item => item.EntryDate)
                                   .ThenBy(item => item.CreatedDate)
                                   .ThenBy(item => item.Title);
                }

                indexresults = indexresults.Skip(criteria.PageSize * (criteria.PageNumber - 1))
                               .Take(criteria.PageSize < int.MaxValue ? criteria.PageSize + 1 : criteria.PageSize);

                var entries = indexresults.Select(resultItem =>
                                                  // Keep field access inline so the query analyzer can see which fields will be used.
                                                  new Entry
                {
                    Uri       = resultItem.Uri,
                    Title     = string.IsNullOrWhiteSpace(resultItem.Title) ? resultItem.Name : resultItem.Title,
                    Tags      = resultItem.Tags != null ? resultItem.Tags : Enumerable.Empty <string>(),
                    EntryDate = resultItem.EntryDate
                }
                                                  ).ToList();


                var hasMore = entries.Count > criteria.PageSize;

                var entriesPage = entries.Take(criteria.PageSize).ToList();
                var results     = new SearchResults <Entry>(entriesPage, hasMore);

                EntryCache?.Set(criteria, resultOrder, results);

                return(results);
            }
        }
示例#19
0
 public void Remove(OrderItem item)
 {
     ListOrder.Remove(item);
 }
示例#20
0
 public void Add(OrderItem item)
 {
     ListOrder.Add(item);
 }
 /// <summary>
 /// Lookup list by base list's index offset. If the list at index offset is not found,
 /// create it with the given sort order at that index offset. If pad is true and the
 /// index offset is greater than the bounds of the base list, nil entries will be
 /// inserted before the newly created list.
 /// </summary>
 public static CTX ListIndexCreate(int index, ListOrder order, bool pad)
 {
     return(new CTX(0x10 | GetFlag(order, pad), Value.Get(index)));
 }
 internal static int GetFlag(ListOrder order, bool pad)
 {
     return((order == ListOrder.ORDERED) ? 0xc0 : pad ? 0x80 : 0x40);
 }
示例#23
0
 /// <summary>
 /// Create list with specified order when list does not exist.
 /// Use specified write flags when writing list items.
 /// </summary>
 public ListPolicy(ListOrder order, ListWriteFlags flags)
 {
     this.attributes = (int)order;
     this.flags      = (int)flags;
 }
示例#24
0
 /// <summary>
 /// Create set list order operation.
 /// Server sets list order.  Server returns null.
 /// </summary>
 public static Operation SetOrder(string binName, ListOrder order, params CTX[] ctx)
 {
     byte[] bytes = PackUtil.Pack(ListOperation.SET_TYPE, (int)order, ctx);
     return(new Operation(Operation.Type.CDT_MODIFY, binName, Value.Get(bytes)));
 }
示例#25
0
 /// <summary>
 /// Create set list order operation.
 /// Server sets list order.  Server returns null.
 /// </summary>
 public static Operation SetOrder(string binName, ListOrder order, params CTX[] ctx)
 {
     return(CDT.CreateOperation(SET_TYPE, Operation.Type.CDT_MODIFY, binName, ctx, (int)order));
 }
示例#26
0
        protected SearchResults <Model.Entry> GetEntriesCloseToEntry(EntryItem entry, ListOrder resultOrder, Action <EntryCriteria> mutator)
        {
            var blogHomeItem = BlogManager.GetCurrentBlog(entry);

            if (blogHomeItem == null)
            {
                return(null);
            }

            var pageSizes = new[] { 5, 50, 100, int.MaxValue };

            foreach (var pageSize in pageSizes)
            {
                var criteria = new EntryCriteria
                {
                    PageNumber = 1,
                    PageSize   = pageSize
                };

                mutator.Invoke(criteria);

                var entries = EntryManager.GetBlogEntries(blogHomeItem, criteria, resultOrder);

                for (var i = 0; i < entries.Results.Count; i++)
                {
                    if (entries.Results[i].Uri.ItemID == entry.ID && i < entries.Results.Count - 1)
                    {
                        return(entries);
                    }
                }
            }

            return(null);
        }