Exemplo n.º 1
0
        static private void Subquery()
        {
            OrdersQuery       orders  = new OrdersQuery("o");
            OrderDetailsQuery details = new OrderDetailsQuery("oi");

            orders.Select
            (
                orders.OrderID,
                orders.OrderDate,
                details.Select
                (
                    details.UnitPrice.Max()
                )
                .Where(orders.OrderID == details.OrderID).As("MaxUnitPrice")
            );

            OrdersCollection coll = new OrdersCollection();

            if (coll.Load(orders))
            {
                foreach (Orders order in coll)
                {
                }
            }
        }
Exemplo n.º 2
0
        public int OrderDetails_GetCount(string serializedQuery)
        {
            OrderDetailsQuery query = OrderDetailsQuery.SerializeHelper.FromXml(
                serializedQuery, typeof(OrderDetailsQuery), AllKnownTypes) as OrderDetailsQuery;

            return(query.ExecuteScalar <int>());
        }
Exemplo n.º 3
0
        public List <CanelModel> PostOrderDetail(OrderDetailsQuery odq)
        {
            var list = new List <Expression <Func <Order, bool> > >();

            if (!string.IsNullOrEmpty(odq.OrderCode))
            {
                list.Add(o => o.OrderCode == odq.OrderCode);
            }

            if (!string.IsNullOrEmpty(odq.PhoneCode))
            {
                list.Add(o => o.Customer.CPhone == odq.PhoneCode);
            }
            if (odq.OrderStartDate != DateTime.MinValue && odq.OrderEndDate.Date >= odq.OrderStartDate.Date)
            {
                list.Add(o => o.OrderDate > odq.OrderStartDate.Date);
            }
            if (odq.OrderEndDate != DateTime.MinValue && odq.OrderEndDate.Date >= odq.OrderStartDate.Date)
            {
                list.Add(o => o.OrderDate < odq.OrderEndDate.Date.AddHours(23).AddMinutes(59));
            }
            if (!string.IsNullOrEmpty(odq.CertCode))
            {
                var id     = db.OrderItems.FirstOrDefault(oi => oi.CertificateNum == odq.CertCode).OrderId;
                var orders = db.Orders.Include("Customer").Where(o => o.Id == id).Select(c => new CanelModel
                {
                    Id          = c.Id,
                    OrderCode   = c.OrderCode,
                    OrderDate   = c.OrderDate,
                    OrderStatus = c.OrderStatus,
                    CName       = c.Customer.CName,
                    CPhone      = c.Customer.CPhone
                }).ToList();
                return(orders);
            }
            else
            {
                Expression <Func <Order, bool> > express = PredicateBuilder.True <Order>();
                foreach (var item in list)
                {
                    express = express.And(item);
                }

                var orders = db.Orders.Include("Customer").Where(express).OrderByDescending(o => o.OrderDate).Select(c => new CanelModel
                {
                    Id          = c.Id,
                    OrderCode   = c.OrderCode,
                    OrderDate   = c.OrderDate,
                    OrderStatus = c.OrderStatus,
                    CName       = c.Customer.CName,
                    CPhone      = c.Customer.CPhone
                }).ToList();
                return(orders);
            }
        }
Exemplo n.º 4
0
        public OrderDetailsCollection OrderDetails_LoadByDynamic(string serializedQuery)
        {
            OrderDetailsQuery query = OrderDetailsQuery.SerializeHelper.FromXml(
                serializedQuery, typeof(OrderDetailsQuery), AllKnownTypes) as OrderDetailsQuery;

            OrderDetailsCollection coll = new OrderDetailsCollection();

            coll.es.IsLazyLoadDisabled = true;
            coll.Load(query);
            return(coll);
        }
        public OrderDetailsProxyStub OrderDetails_QueryForEntity(string serializedQuery)
        {
            OrderDetailsQuery query = OrderDetailsQuery.SerializeHelper.FromXml(
                serializedQuery, typeof(OrderDetailsQuery), AllKnownTypes) as OrderDetailsQuery;

            OrderDetails obj = new OrderDetails();

            if (obj.Load(query))
            {
                return(obj);
            }

            return(null);
        }
        public OrderDetailsCollectionProxyStub OrderDetails_QueryForCollection(string serializedQuery)
        {
            OrderDetailsQuery query = OrderDetailsQuery.SerializeHelper.FromXml(
                serializedQuery, typeof(OrderDetailsQuery), AllKnownTypes) as OrderDetailsQuery;

            OrderDetailsCollection coll = new OrderDetailsCollection();

            if (coll.Load(query))
            {
                return(coll);
            }

            return(null);
        }
Exemplo n.º 7
0
        public async Task <CustomerDetailsDto> GetCustomerDetails(OrderDetailsQuery request)
        {
            var baseUrl = _appSettings.CustomerDetailsServiceBaseUrl;
            var code    = _appSettings.CustomerDetailsServiceCode;
            var email   = request.User;

            var endpoint = $"/api/GetUserDetails?code={code}&&email={email}";

            var client = new CustomerDetailsClient(baseUrl);

            var customerDetailsDto = await client.Process(endpoint);

            return(customerDetailsDto);
        }
Exemplo n.º 8
0
        static private void CorrelatedSubQuery()
        {
            OrderDetailsQuery oiq = new OrderDetailsQuery("oi");
            ProductsQuery     pq  = new ProductsQuery("p");

            oiq.Select(oiq.OrderID, (oiq.Quantity * oiq.UnitPrice).Sum().As("Total"))
            .Where(oiq.ProductID
                   .In(
                       pq.Select(pq.ProductID).Where(oiq.ProductID == pq.ProductID).Distinct()
                       )
                   )
            .GroupBy(oiq.OrderID);

            OrderDetailsCollection coll = new OrderDetailsCollection();

            if (coll.Load(oiq))
            {
            }
        }
Exemplo n.º 9
0
        public async Task It_Fetches_Most_Recent_Order_With_Gifts_As_OrderItems()
        {
            var request = new OrderDetailsQuery()
            {
                CustomerId = "1",
                User       = "******"
            };

            var customerDetailsDto = new CustomerDetailsDto()
            {
                CustomerId  = "1",
                FirstName   = "FirstName",
                LastName    = "LastName",
                HouseNumber = "1A",
                Postcode    = "PostCode",
                Street      = "Street",
                Town        = "Town"
            };

            _customerDetailsService.Setup(s => s.GetCustomerDetails(It.IsAny <OrderDetailsQuery>()))
            .ReturnsAsync(customerDetailsDto);

            var order3 = CreateOrder(containsGift: true, customerId: "1", orderDate: new System.DateTime(2020, 10, 20), orderId: 3);
            var order4 = CreateOrder(containsGift: false, customerId: "1", orderDate: new System.DateTime(2020, 10, 19), orderId: 4);

            var orders = new List <Order> {
                order3, order4
            };

            SeedContext(orders: orders);

            _SUT = new OrderDetailsQueryHandler(_context.Object, _customerDetailsService.Object);

            var orderDetailsDto = await _SUT.Handle(request, new System.Threading.CancellationToken());

            orderDetailsDto.Order.OrderNumber.Should().Be(3);
            orderDetailsDto.Order.DeliveryAddress.Should().Be("1A Street, Town, PostCode");
            orderDetailsDto.Order.OrderDate.Should().Be("20-October-2020");
            orderDetailsDto.Order.OrderItems.Count.Should().Be(2);
            orderDetailsDto.Order.OrderItems[0].Product.Should().Be("Gift");
            orderDetailsDto.Order.OrderItems[1].Product.Should().Be("Gift");
        }
        public jsResponse <EmployeesCollection, Employees> Employees_LoadHierarchical()
        {
            jsResponse <EmployeesCollection, Employees> response = new jsResponse <EmployeesCollection, Employees>();

            try
            {
                // The Main Query
                EmployeesQuery q = new EmployeesQuery("e");
                q.Select(q.EmployeeID, q.FirstName, q.LastName, q.City, q.Country, q.HomePhone, q.Region, q.PostalCode, q.Title);
                q.Where(q.EmployeeID < 7);

                // The OrdersCollection
                OrdersQuery    o1   = q.Prefetch <OrdersQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID);
                EmployeesQuery emp1 = o1.GetQuery <EmployeesQuery>();
                o1.Where(emp1.EmployeeID < 7);

                // The OrdersDetailsCollection
                OrderDetailsQuery od   = q.Prefetch <OrderDetailsQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID, Orders.Prefetch_OrderDetailsCollectionByOrderID);
                EmployeesQuery    emp2 = od.GetQuery <EmployeesQuery>();
                OrdersQuery       o2   = od.GetQuery <OrdersQuery>();
                od.Where(emp2.EmployeeID < 7);

                // Load It
                EmployeesCollection coll = new EmployeesCollection();
                if (coll.Load(q))
                {
                    response.collection = coll;

                    response.columnCollection["Employees"]    = jsColumn.PopulateColumns(coll[0]);
                    response.columnCollection["Orders"]       = jsColumn.PopulateColumns(coll[0].OrdersCollectionByEmployeeID[0]);
                    response.columnCollection["OrderDetails"] = jsColumn.PopulateColumns(coll[0].OrdersCollectionByEmployeeID[0].OrderDetailsCollectionByOrderID[0]);
                }
            }
            catch (Exception ex)
            {
                response.exception = ex.Message;
            }

            return(response);
        }
Exemplo n.º 11
0
        public async Task <ActionResult> OrderDetails([FromBody] OrderDetailsQuery request)
        {
            try
            {
                var dto = await Mediator.Send(request);

                return(Ok(dto));
            }
            catch (CustomerDetailsHttpResponseException)
            {
                return(ActionResultHelper.ToBadRequestActionResult(message: "Error While Fetching Customer Details", title: "Error", statusCode: StatusCodes.Status500InternalServerError));
            }
            catch (InvalidUser ex)
            {
                return(ActionResultHelper.ToBadRequestActionResult(message: ex.Message, title: "User Not Found", statusCode: StatusCodes.Status404NotFound));
            }

            catch (Exception ex)
            {
                return(ActionResultHelper.ToBadRequestActionResult(message: ex.Message, title: "Error", statusCode: StatusCodes.Status500InternalServerError));
            }
        }
        public EmployeesCollection Employees_PrefetchSophisticated()
        {
            // EmployeeID = "1"
            EmployeesCollection coll = new EmployeesCollection();

            coll.Query.Where(coll.Query.EmployeeID == 1);

            // Orders Query (nothing fancy, just ensure we're only getting Orders for EmployeeID = 1
            OrdersQuery    o  = coll.Query.Prefetch <OrdersQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID);
            EmployeesQuery e1 = o.GetQuery <EmployeesQuery>();

            o.Where(e1.EmployeeID == 1);

            // OrderDetailsQuery (here we even limit the Select in addition to  EmployeeID = 1) notice the "false"
            OrderDetailsQuery od = coll.Query.Prefetch <OrderDetailsQuery>(false, Employees.Prefetch_OrdersCollectionByEmployeeID, Orders.Prefetch_OrderDetailsCollectionByOrderID);
            EmployeesQuery    e2 = od.GetQuery <EmployeesQuery>();

            od.Where(e2.EmployeeID == 1);
            od.Select(od.OrderID, od.ProductID, od.UnitPrice);

            coll.Query.Load();
            return(coll);
        }
Exemplo n.º 13
0
        static private void CaseWhenThenEnd()
        {
            OrderDetailsQuery oq = new OrderDetailsQuery();

            oq.Select
            (
                oq.Quantity,
                oq.UnitPrice,
                oq.UnitPrice
                .Case()
                .When(oq.Quantity < 50).Then(oq.UnitPrice)
                .When(oq.Quantity >= 50 && oq.Quantity < 70).Then(oq.UnitPrice * .90)
                .When(oq.Quantity >= 70 && oq.Quantity < 99).Then(oq.UnitPrice * .80)
                .Else(oq.UnitPrice * .70)
                .End().As("Adjusted Unit Price")
            ).OrderBy(oq.Quantity.Descending);

            OrderDetailsCollection coll = new OrderDetailsCollection();

            if (coll.Load(oq))
            {
            }
        }