public List <OrderWorkerDTO> Get()
        {
            try
            {
                MessageQueue messageQueue    = null;
                var          orderRepository = new OrderRepository();
                if (MessageQueue.Exists(@".\Private$\PizzeriaMP"))
                {
                    messageQueue = new MessageQueue(@".\Private$\PizzeriaMP");
                    var messages = messageQueue.GetAllMessages();
                    foreach (var item in messages)
                    {
                        messageQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(OrderDTO) });
                        Message  message = messageQueue.Receive();
                        OrderDTO order   = (OrderDTO)message.Body;

                        orderRepository.InsertOrder(order);
                    }
                }
                var criteria = new OrderSearchCriteriaDTO()
                {
                    OrderStatusId = 1
                };
                var result = orderRepository.GetOrdersByCriteria(criteria);
                return(result);
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        public IList <OrderDTO> GetOrders(int pageNo, int pageSize, OrderSearchCriteriaDTO criteria = null)
        {
            using (var session = Hibernate.SessionFactory.OpenSession())
            {
                Recipes_Model.Entities.Order o = null;
                OrderDTO dto = null;

                var orders = session.QueryOver(() => o)
                             .SelectList(list => list
                                         .Select(() => o.Id).WithAlias(() => dto.Id)
                                         .Select(() => o.Name).WithAlias(() => dto.Name)
                                         .Select(() => o.OrderNo).WithAlias(() => dto.OrderNo)
                                         .Select(() => o.Comments).WithAlias(() => dto.Comments)
                                         .Select(() => o.ItemCount).WithAlias(() => dto.ItemCount)
                                         .Select(() => o.Date).WithAlias(() => dto.Date));

                if (criteria != null)
                {
                    if (criteria.OrderName.IsNotNull())
                    {
                        orders.Where(Restrictions.InsensitiveLike(nameof(o.Name), criteria.OrderName, MatchMode.Anywhere));
                    }
                    if (criteria.OrderNo.IsNotNull())
                    {
                        orders.Where(Restrictions.InsensitiveLike(nameof(o.OrderNo), criteria.OrderNo, MatchMode.Anywhere));
                    }
                    if (criteria.OrderDate.IsNotNull())
                    {
                        orders.Where(() => o.Date.Date == criteria.OrderDate.Value.Date);
                    }
                    if (criteria.ComponentName.IsNotNull())
                    {
                        Recipe    r = null;
                        Product   p = null;
                        Mount     m = null;
                        Component c = null;

                        orders
                        .JoinAlias(() => o.Recipes, () => r)
                        .JoinAlias(() => r.Product, () => p)
                        .JoinAlias(() => p.Mounts, () => m)
                        .JoinAlias(() => m.Component, () => c)
                        .Where(Restrictions.InsensitiveLike("c.Name", criteria.ComponentName, MatchMode.Anywhere));
                    }
                }

                return(orders
                       .OrderBy(() => o.Name).Asc
                       .TransformUsing(Transformers.AliasToBean <OrderDTO>())
                       .Skip((pageNo - 1) * pageSize).Take(pageSize)
                       .List <OrderDTO>());
            }
        }
        public List <OrderWorkerDTO> GetOrdersByCriteria(OrderSearchCriteriaDTO criteria)
        {
            using (var context = new PizzeriaMasterpieceEntities())
            {
                var query = context.Orders.Where(p => p.UserId == criteria.UserId || criteria.UserId == null);
                query = query.Where(p => p.OrderStatusId == criteria.OrderStatusId || criteria.OrderStatusId == null);
                query = query.Where(p => p.Date >= criteria.StartDate || criteria.StartDate == null);
                query = query.Where(p => p.Date <= criteria.EndDate || criteria.EndDate == null);

                var result = query.Select(q => new OrderWorkerDTO
                {
                    OrderId          = q.OrderId,
                    OrderNo          = q.OrderNo,
                    Address          = q.Address,
                    Date             = q.Date,
                    Remark           = q.Remark,
                    DocumentTypeId   = q.DocumentTypeId,
                    DocumentTypeName = q.DocumentType.Name,
                    OrderStatusId    = q.OrderStatusId,
                    OrderStatusName  = q.OrderStatu.Name,
                    DocumentNo       = q.User.DocumentNo,
                    Email            = q.User.Email,
                    FirstName        = q.User.FirstName,
                    LastName         = q.User.LastName,
                    PhoneNumber      = q.User.PhoneNumber,
                    OrderDetails     = q.OrderDetails.Select(r => new OrderDetailDTO
                    {
                        OrderDetailId = r.OrderDetailId,
                        ProductId     = r.ProductId.Value,
                        ProductName   = r.Product.Name,
                        Price         = r.Price,
                        Quantity      = r.Quantity,
                        TotalPrice    = r.TotalPrice,
                        Supplies      = r.Product.ProductSupplies.Select(p => new SupplyDTO
                        {
                            SupplyId    = p.Supply.SupplyId,
                            Code        = p.Supply.Code,
                            Description = p.Supply.Description,
                            IsActive    = p.Supply.IsActive,
                            Name        = p.Supply.Name,
                            Quantity    = p.Supply.Quantity
                        }).ToList()
                    }).ToList()
                }).OrderByDescending(q => q.Date).ToList();

                return(result);
            }
        }
        public int GetOrdersCount(int pageNo, int pageSize, OrderSearchCriteriaDTO criteria = null)
        {
            using (var session = Hibernate.SessionFactory.OpenSession())
            {
                Recipes_Model.Entities.Order o = null;
                var count = session.QueryOver(() => o);

                if (criteria != null)
                {
                    if (criteria.OrderName.IsNotNull())
                    {
                        count.Where(Restrictions.InsensitiveLike(nameof(o.Name), criteria.OrderName, MatchMode.Anywhere));
                    }
                    if (criteria.OrderNo.IsNotNull())
                    {
                        count.Where(Restrictions.InsensitiveLike(nameof(o.OrderNo), criteria.OrderNo, MatchMode.Anywhere));
                    }
                    if (criteria.OrderDate.IsNotNull())
                    {
                        count.Where(() => o.Date.Date == criteria.OrderDate.Value.Date);
                    }
                    if (criteria.ComponentName.IsNotNull())
                    {
                        Recipe    r = null;
                        Product   p = null;
                        Mount     m = null;
                        Component c = null;

                        count
                        .JoinAlias(() => o.Recipes, () => r)
                        .JoinAlias(() => r.Product, () => p)
                        .JoinAlias(() => p.Mounts, () => m)
                        .JoinAlias(() => m.Component, () => c)
                        .Where(Restrictions.InsensitiveLike("c.Name", criteria.ComponentName, MatchMode.Anywhere));
                    }
                }

                var result = Convert.ToInt32(Math.Ceiling((1.0 * count.RowCount()) / pageSize));
                return(result == 0 ? 1 : result);
            }
        }