Ejemplo n.º 1
0
        public IResult <IInventoryReturn> GetInventory(FilterInventoryParameters parameters = null)
        {
            InventoryPredicateBuilder.PredicateBuilderFilters filters = null;
            if (parameters != null)
            {
                var filterResults = parameters.ParseToPredicateBuilderFilters();
                if (!filterResults.Success)
                {
                    return(filterResults.ConvertTo((IInventoryReturn)null));
                }
                filters = filterResults.ResultingObject;
            }

            return(new GetInventoryCommand(_inventoryUnitOfWork).Execute(filters, _timeStamper.CurrentTimeStamp.Date));
        }
Ejemplo n.º 2
0
        internal IResult <PickableInventoryReturn> Execute(InventoryPredicateBuilder.PredicateBuilderFilters filters, DateTime currentDate, IInventoryValidator validator, bool includeAllowances)
        {
            var splitProjectors = InventoryProjectors.SplitSelectPickableInventorySummary(_inventoryUnitOfWork, currentDate, validator.ValidForPickingPredicates, includeAllowances);
            var predicateResult = InventoryPredicateBuilder.BuildPredicate(_inventoryUnitOfWork, filters, validator.InventoryFilters);

            if (!predicateResult.Success)
            {
                return(predicateResult.ConvertTo <PickableInventoryReturn>());
            }

            return(new SuccessResult <PickableInventoryReturn>(new PickableInventoryReturn
            {
                Items = _inventoryUnitOfWork.InventoryRepository
                        .Filter(predicateResult.ResultingObject)
                        .SplitSelect(splitProjectors)
            }));
        }
Ejemplo n.º 3
0
        internal IResult <IInventoryReturn> Execute(InventoryPredicateBuilder.PredicateBuilderFilters filters, DateTime currentDate)
        {
            var predicateResult = InventoryPredicateBuilder.BuildPredicate(_inventoryUnitOfWork, filters);

            if (!predicateResult.Success)
            {
                return(predicateResult.ConvertTo <IInventoryReturn>());
            }

            var attributes = AttributeNameProjectors.SelectActiveAttributeNames(_inventoryUnitOfWork);
            var inventory  = _inventoryUnitOfWork.InventoryRepository
                             .Filter(predicateResult.ResultingObject)
                             .SplitSelect(InventoryProjectors.SplitSelectInventorySummary(_inventoryUnitOfWork, currentDate));

            var inventoryReturn = new InventoryReturn
            {
                AttributeNamesAndTypes = attributes.ExpandAll().Invoke(),
                Inventory = inventory
            };

            if (!inventoryReturn.Inventory.Any())
            {
                if (filters != null && filters.LotKey != null)
                {
                    var lotKey = new LotKey(filters.LotKey);
                    if (!_inventoryUnitOfWork.OptimizeForReadonly().LotRepository
                        .All()
                        .AsExpandable()
                        .AsNoTracking()
                        .Any(lotKey.FindByPredicate))
                    {
                        return(new InvalidResult <IInventoryReturn>(null, string.Format(UserMessages.LotNotFound, lotKey.KeyValue)));
                    }
                }
            }

            return(new SuccessResult <IInventoryReturn>(inventoryReturn));
        }
        private static IResult <InventoryPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterInventoryParametersBase parameters)
        {
            var result = new InventoryPredicateBuilder.PredicateBuilderFilters();

            if (!string.IsNullOrWhiteSpace(parameters.LotKey))
            {
                var lotKeyResult = KeyParserHelper.ParseResult <ILotKey>(parameters.LotKey);
                if (!lotKeyResult.Success)
                {
                    return(lotKeyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.LotKey = lotKeyResult.ResultingObject;
            }

            if (!string.IsNullOrWhiteSpace(parameters.ProductKey))
            {
                var productKeyResult = KeyParserHelper.ParseResult <IProductKey>(parameters.ProductKey);
                if (!productKeyResult.Success)
                {
                    return(productKeyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.ProductKey = productKeyResult.ResultingObject;
            }

            if (!string.IsNullOrWhiteSpace(parameters.TreatmentKey))
            {
                var keyResult = KeyParserHelper.ParseResult <IInventoryTreatmentKey>(parameters.TreatmentKey);
                if (!keyResult.Success)
                {
                    return(keyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.TreatmentKey = keyResult.ResultingObject;
            }

            if (!string.IsNullOrWhiteSpace(parameters.PackagingKey))
            {
                var keyResult = KeyParserHelper.ParseResult <IPackagingProductKey>(parameters.PackagingKey);
                if (!keyResult.Success)
                {
                    return(keyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.PackagingKey = keyResult.ResultingObject;
            }

            if (!string.IsNullOrWhiteSpace(parameters.PackagingReceivedKey))
            {
                var keyResult = KeyParserHelper.ParseResult <IPackagingProductKey>(parameters.PackagingReceivedKey);
                if (!keyResult.Success)
                {
                    return(keyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.PackagingReceivedKey = keyResult.ResultingObject;
            }

            if (!string.IsNullOrWhiteSpace(parameters.LocationKey))
            {
                var keyResult = KeyParserHelper.ParseResult <ILocationKey>(parameters.LocationKey);
                if (!keyResult.Success)
                {
                    return(keyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
                }
                result.LocationKey = keyResult.ResultingObject;
            }

            result.ProductType       = parameters.ProductType;
            result.LotType           = parameters.LotType;
            result.HoldType          = parameters.HoldType;
            result.LocationGroupName = parameters.LocationGroupName;

            return(new SuccessResult <InventoryPredicateBuilder.PredicateBuilderFilters>(result));
        }