public static IList <SubdivisionRecivedInfo> ItemsBalance(IUnitOfWork uow, Subdivision subdivision)
        {
            if (subdivision.Id == 0)            //Если подразделение не сохранено возвращаем пустой лист.
            {
                return(new List <SubdivisionRecivedInfo>());
            }

            SubdivisionRecivedInfo resultAlias = null;

            SubdivisionIssueOperation subdivisionIssueOperationAlias = null;
            Nomenclature     nomenclatureAlias     = null;
            ItemsType        itemsTypeAlias        = null;
            MeasurementUnits measurementUnitsAlias = null;
            SubdivisionPlace subdivisionPlaceAlias = null;

            IProjection projection = Projections.Sum(Projections.SqlFunction(
                                                         new SQLFunctionTemplate(NHibernateUtil.Int32, "IFNULL(?1, 0) - IFNULL(?2, 0)"),
                                                         NHibernateUtil.Int32,
                                                         Projections.Property <SubdivisionIssueOperation>(x => x.Issued),
                                                         Projections.Property <SubdivisionIssueOperation>(x => x.Returned)
                                                         ));

            var incomeList = uow.Session.QueryOver <SubdivisionIssueOperation>(() => subdivisionIssueOperationAlias)
                             .Where(x => x.Subdivision == subdivision)
                             .JoinAlias(() => subdivisionIssueOperationAlias.Nomenclature, () => nomenclatureAlias)
                             .JoinAlias(() => nomenclatureAlias.Type, () => itemsTypeAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
                             .JoinAlias(() => itemsTypeAlias.Units, () => measurementUnitsAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
                             .JoinAlias(() => subdivisionIssueOperationAlias.SubdivisionPlace, () => subdivisionPlaceAlias, NHibernate.SqlCommand.JoinType.LeftOuterJoin)
                             .SelectList(list => list
                                         .SelectGroup(() => nomenclatureAlias.Id).WithAlias(() => resultAlias.NomenclatureId)
                                         .SelectGroup(() => subdivisionIssueOperationAlias.WearPercent).WithAlias(() => resultAlias.WearPercent)
                                         .SelectGroup(() => subdivisionIssueOperationAlias.SubdivisionPlace.Id).WithAlias(() => resultAlias.PlaceId)
                                         .Select(() => nomenclatureAlias.Name).WithAlias(() => resultAlias.NomeclatureName)
                                         .Select(() => subdivisionPlaceAlias.Name).WithAlias(() => resultAlias.Place)
                                         .SelectMax(() => subdivisionIssueOperationAlias.OperationTime).WithAlias(() => resultAlias.LastReceive)
                                         .Select(projection).WithAlias(() => resultAlias.Amount)
                                         )
                             .Where(Restrictions.Gt(projection, 0))
                             .TransformUsing(Transformers.AliasToBean <SubdivisionRecivedInfo>())
                             .List <SubdivisionRecivedInfo>();

            return(incomeList);
        }
        public void IssuingToSubdivisionTest()
        {
            var ask = Substitute.For <IInteractiveQuestion>();

            ask.Question(string.Empty).ReturnsForAnyArgs(true);
            var baseParameters = Substitute.For <BaseParameters>();

            baseParameters.ColDayAheadOfShedule.Returns(0);

            using (var uow = UnitOfWorkFactory.CreateWithoutRoot()) {
                var warehouse = new Warehouse();
                uow.Save(warehouse);

                var sizeType = new SizeType();
                uow.Save(sizeType);

                var nomenclatureType = new ItemsType {
                    Name     = "Тестовый тип номенклатуры",
                    SizeType = sizeType
                };
                uow.Save(nomenclatureType);

                var nomenclature = new Nomenclature {
                    Name = "Тестовая номеклатура",
                    Type = nomenclatureType
                };
                uow.Save(nomenclature);

                var size = new Size {
                    SizeType = sizeType
                };
                var height = new Size();
                uow.Save(size);
                uow.Save(height);

                var position1 = new StockPosition(nomenclature, 0, size, height);

                var subdivision = new Subdivision {
                    Name = "Тестовое подразделение"
                };
                uow.Save(subdivision);

                var place = new SubdivisionPlace {
                    Name        = "Тестовое место",
                    Subdivision = subdivision
                };
                uow.Save(place);

                var income = new Income {
                    Warehouse = warehouse,
                    Date      = new DateTime(2017, 1, 1),
                    Operation = IncomeOperations.Enter
                };
                var incomeItem1 = income.AddItem(nomenclature);
                incomeItem1.Amount = 10;
                income.UpdateOperations(uow, ask);
                uow.Save(income);

                var expense = new Expense {
                    Operation   = ExpenseOperations.Object,
                    Warehouse   = warehouse,
                    Subdivision = subdivision,
                    Date        = new DateTime(2018, 10, 22)
                };
                var item1 = expense.AddItem(position1, 1);
                item1.SubdivisionPlace = place;

                //Обновление операций
                expense.UpdateOperations(uow, baseParameters, ask);
                uow.Save(expense);
                uow.Commit();

                var listed  = SubdivisionRepository.ItemsBalance(uow, subdivision);
                var balance = listed.First();
                Assert.That(balance.Amount, Is.EqualTo(1));
                Assert.That(balance.NomeclatureName, Is.EqualTo("Тестовая номеклатура"));
                Assert.That(balance.Place, Is.EqualTo("Тестовое место"));
                Assert.That(balance.WearPercent, Is.EqualTo(0m));
            }
        }