コード例 #1
0
        public IEnumerable <GoodsInRouteListResult> AllGoodsTransferredTo(IUnitOfWork uow, RouteList routeList)
        {
            if (routeList == null)
            {
                throw new ArgumentNullException(nameof(routeList));
            }

            AddressTransferDocument        transferDocAlias           = null;
            AddressTransferDocumentItem    transferDocItemAlias       = null;
            DriverNomenclatureTransferItem driverTransferDocItemAlias = null;
            GoodsInRouteListResult         resultNodeAlias            = null;

            var result = uow.Session.QueryOver <AddressTransferDocument>(() => transferDocAlias)
                         .Inner.JoinAlias(() => transferDocAlias.AddressTransferDocumentItems, () => transferDocItemAlias)
                         .Inner.JoinAlias(() => transferDocItemAlias.DriverNomenclatureTransferDocumentItems, () => driverTransferDocItemAlias)
                         .Where(() => transferDocAlias.RouteListTo.Id == routeList.Id)
                         .SelectList(list => list
                                     .SelectGroup(() => driverTransferDocItemAlias.Nomenclature.Id).WithAlias(() => resultNodeAlias.NomenclatureId)
                                     .SelectSum(() => driverTransferDocItemAlias.Amount).WithAlias(() => resultNodeAlias.Amount)
                                     ).TransformUsing(Transformers.AliasToBean <GoodsInRouteListResult>())
                         .List <GoodsInRouteListResult>();

            return(result);
        }
コード例 #2
0
        private void CreateOrUpdateAddressTransferDocuments(RouteList from, RouteList to, IUnitOfWork uow)
        {
            var transferDocument = uow.Session.QueryOver <AddressTransferDocument>()
                                   .Where(x => x.RouteListFrom.Id == from.Id)
                                   .And(x => x.RouteListTo.Id == to.Id)
                                   .SingleOrDefault() ?? new AddressTransferDocument();

            foreach (var documentItem in transferDocument.AddressTransferDocumentItems)
            {
                uow.Delete(documentItem);
            }
            transferDocument.ObservableAddressTransferDocumentItems.Clear();

            var employeeForCurrentUser = employeeRepository.GetEmployeeForCurrentUser(uow);

            if (transferDocument.Author == null)
            {
                transferDocument.Author = employeeForCurrentUser;
            }
            if (transferDocument.TimeStamp == default(DateTime))
            {
                transferDocument.TimeStamp = DateTime.Now;
            }

            transferDocument.LastEditor     = employeeForCurrentUser;
            transferDocument.LastEditedTime = DateTime.Now;
            transferDocument.RouteListFrom  = from;
            transferDocument.RouteListTo    = to;

            var transferredAddresses = from.Addresses
                                       .Where(x => to.Addresses.Contains(x.TransferedTo) && x.Status == RouteListItemStatus.Transfered)
                                       .ToList();

            foreach (var address in transferredAddresses)
            {
                var newAddressTransferItem = new AddressTransferDocumentItem {
                    Document     = transferDocument,
                    OldAddress   = address,
                    NewAddress   = address.TransferedTo,
                    NeedToReload = address.TransferedTo.NeedToReload
                };
                transferDocument.ObservableAddressTransferDocumentItems.Add(newAddressTransferItem);

                if (newAddressTransferItem.NeedToReload)
                {
                    continue;
                }

                foreach (var orderItem in newAddressTransferItem.OldAddress.Order.OrderItems)
                {
                    var newDriverNomenclatureTransferItem = new DriverNomenclatureTransferItem {
                        DocumentItem = newAddressTransferItem,
                        Amount       = orderItem.Count,
                        Nomenclature = orderItem.Nomenclature,
                        DriverFrom   = newAddressTransferItem.OldAddress.RouteList.Driver,
                        DriverTo     = newAddressTransferItem.OldAddress.TransferedTo.RouteList.Driver
                    };

                    newDriverNomenclatureTransferItem.CreateOrUpdateOperations();
                    newAddressTransferItem.DriverNomenclatureTransferDocumentItems.Add(newDriverNomenclatureTransferItem);
                }

                foreach (var orderItem in newAddressTransferItem.OldAddress.Order.OrderEquipments.Where(x => x.Direction == Direction.Deliver))
                {
                    var newDriverNomenclatureTransferItem = new DriverNomenclatureTransferItem {
                        DocumentItem = newAddressTransferItem,
                        Amount       = orderItem.Count,
                        Nomenclature = orderItem.Nomenclature,
                        DriverFrom   = newAddressTransferItem.OldAddress.RouteList.Driver,
                        DriverTo     = newAddressTransferItem.OldAddress.TransferedTo.RouteList.Driver
                    };

                    newDriverNomenclatureTransferItem.CreateOrUpdateOperations();
                    newAddressTransferItem.DriverNomenclatureTransferDocumentItems.Add(newDriverNomenclatureTransferItem);
                }
            }

            uow.Save(transferDocument);
        }