コード例 #1
0
 public IResult <IQueryable <ISampleOrderSummaryReturn> > GetSampleOrders(FilterSampleOrdersParameters parameters = null)
 {
     try
     {
         return(_sampleOrderServiceProvider.GetSampleOrders(parameters));
     }
     catch (Exception ex)
     {
         _exceptionLogger.LogException(ex);
         return(new FailureResult <IQueryable <ISampleOrderSummaryReturn> >(null, ex.Message));
     }
 }
コード例 #2
0
        public IResult <IQueryable <ISampleOrderSummaryReturn> > GetSampleOrders(FilterSampleOrdersParameters parameters)
        {
            var parsedFilterParameters = parameters.ParseToPredicateBuilderFilters();

            if (!parsedFilterParameters.Success)
            {
                return(parsedFilterParameters.ConvertTo <IQueryable <ISampleOrderSummaryReturn> >());
            }

            var predicateResult = SampleOrderPredicateBuilder.BuildPredicate(parsedFilterParameters.ResultingObject);

            if (!predicateResult.Success)
            {
                return(predicateResult.ConvertTo <IQueryable <ISampleOrderSummaryReturn> >());
            }
            var predicate = predicateResult.ResultingObject;

            var select = SampleOrderProjectors.SelectSummary();
            var query  = _sampleOrderUnitOfWork.SampleOrderRepository.All().AsExpandable().Where(predicate).Select(select);

            return(new SuccessResult <IQueryable <ISampleOrderSummaryReturn> >(query));
        }
コード例 #3
0
        internal static IResult <SampleOrderPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterSampleOrdersParameters parameters)
        {
            if (parameters == null)
            {
                return(new SuccessResult <SampleOrderPredicateBuilder.PredicateBuilderFilters>());
            }

            var result = new SampleOrderPredicateBuilder.PredicateBuilderFilters
            {
                DateReceivedStart  = parameters.DateReceivedStart,
                DateReceivedEnd    = parameters.DateReceivedEnd,
                DateCompletedStart = parameters.DateCompletedStart,
                DateCompletedEnd   = parameters.DateCompletedEnd,
                Status             = parameters.Status,
            };

            if (!string.IsNullOrWhiteSpace(parameters.RequestedCompanyKey))
            {
                var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(parameters.RequestedCompanyKey);
                if (!customerKeyResult.Success)
                {
                    return(customerKeyResult.ConvertTo <SampleOrderPredicateBuilder.PredicateBuilderFilters>());
                }

                result.RequestedCustomerKey = customerKeyResult.ResultingObject.ToCustomerKey();
            }

            if (!string.IsNullOrWhiteSpace(parameters.BrokerKey))
            {
                var companyKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(parameters.BrokerKey);
                if (!companyKeyResult.Success)
                {
                    return(companyKeyResult.ConvertTo <SampleOrderPredicateBuilder.PredicateBuilderFilters>());
                }

                result.BrokerKey = companyKeyResult.ResultingObject.ToCompanyKey();
            }

            return(new SuccessResult <SampleOrderPredicateBuilder.PredicateBuilderFilters>(result));
        }
コード例 #4
0
            public void Returns_SampleOrders_filtered_as_expected()
            {
                //Arrange
                var broker   = TestHelper.CreateObjectGraphAndInsertIntoDatabase <Company>(c => c.SetCompanyTypes(CompanyType.Broker));
                var customer = TestHelper.CreateObjectGraphAndInsertIntoDatabase <Customer>();
                var filters  = new FilterSampleOrdersParameters
                {
                    DateReceivedStart   = new DateTime(2016, 2, 1),
                    DateReceivedEnd     = new DateTime(2016, 2, 10),
                    DateCompletedStart  = new DateTime(2016, 3, 1),
                    DateCompletedEnd    = new DateTime(2016, 3, 10),
                    Status              = SampleOrderStatus.Sent,
                    BrokerKey           = broker.ToCompanyKey(),
                    RequestedCompanyKey = customer.ToCustomerKey()
                };

                var expected = new List <SampleOrder>();

                for (var i = 0; i < 3; ++i)
                {
                    expected.Add(TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                                 o.DateReceived       = filters.DateReceivedStart.Value.AddDays(1),
                                                                                                 o => o.DateCompleted = filters.DateCompletedStart.Value.AddDays(1),
                                                                                                 o => o.Status        = filters.Status.Value,
                                                                                                 o => o.SetBroker(broker).SetRequestCustomer(customer)));
                }

                TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                o.DateReceived       = filters.DateReceivedEnd.Value.AddDays(1),
                                                                                o => o.DateCompleted = filters.DateCompletedStart.Value.AddDays(1),
                                                                                o => o.Status        = filters.Status.Value,
                                                                                o => o.SetBroker(broker).SetRequestCustomer(customer));

                TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                o.DateReceived       = filters.DateReceivedStart.Value.AddDays(1),
                                                                                o => o.DateCompleted = filters.DateCompletedEnd.Value.AddDays(1),
                                                                                o => o.Status        = filters.Status.Value,
                                                                                o => o.SetBroker(broker).SetRequestCustomer(customer));

                TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                o.DateReceived       = filters.DateReceivedStart.Value.AddDays(1),
                                                                                o => o.DateCompleted = filters.DateCompletedStart.Value.AddDays(1),
                                                                                o => o.Status        = SampleOrderStatus.Approved,
                                                                                o => o.SetBroker(broker).SetRequestCustomer(customer));

                TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                o.DateReceived       = filters.DateReceivedStart.Value.AddDays(1),
                                                                                o => o.DateCompleted = filters.DateCompletedStart.Value.AddDays(1),
                                                                                o => o.Status        = filters.Status.Value,
                                                                                o => o.SetBroker(null).SetRequestCustomer(customer));

                TestHelper.CreateObjectGraphAndInsertIntoDatabase <SampleOrder>(o =>
                                                                                o.DateReceived       = filters.DateReceivedStart.Value.AddDays(1),
                                                                                o => o.DateCompleted = filters.DateCompletedStart.Value.AddDays(1),
                                                                                o => o.Status        = filters.Status.Value,
                                                                                o => o.SetBroker(broker).SetRequestCustomer(null));

                //Act
                var result  = Service.GetSampleOrders(filters);
                var results = result.Success ? result.ResultingObject.ToList() : null;

                //Assert
                result.AssertSuccess();
                expected.AssertEquivalent(results, e => e.ToSampleOrderKey().KeyValue, r => r.SampleRequestKey,
                                          (e, r) => e.AssertEqual(r));
            }