public void Can_attach_modified_entity()
        {
            var customer = new Customer
            {
                FirstName = "John",
                LastName = "Doe"
            };

            var context = (OrderEntities) OrdersContextProvider();
            context.AddToCustomers(customer);
            #if EF_1_0
            context.SaveChanges(true);
            #else
            context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
            #endif
            context.Detach(customer);
            context.Dispose();

            using (var scope = new UnitOfWorkScope())
            {
                customer.LastName = "Changed";
                var repository = new EFRepository<Customer>();
                repository.Attach(customer);
                scope.Commit();
            }

            using (var testData = new EFTestData(OrdersContextProvider()))
            {
                Customer savedCustomer = null;
                testData.Batch(x => savedCustomer = x.GetCustomerById(customer.CustomerID));
                Assert.That(savedCustomer, Is.Not.Null);
                Assert.That(savedCustomer.LastName, Is.EqualTo("Changed"));
            }
        }

        public void Can_attach()
        {
            var customer = new Customer
            {
                FirstName = "Jane",
                LastName = "Doe"
            };
            var session = NHTestUtil.OrdersDomainFactory.OpenSession();
            ITransaction transaction = session.BeginTransaction();
            session.Save(customer);
            transaction.Commit();
            session.Evict(customer); //Detching from owning session
            session.Dispose(); //Auto flush

            using (var scope = new UnitOfWorkScope())
            {
                var repository = new NHRepository<Customer,int>();
                repository.Attach(customer);
                customer.LastName = "Changed";
                scope.Commit(); //Should change since the customer was attached to repository.
            }

            using (var testData = new NHTestData(NHTestUtil.OrdersDomainFactory.OpenSession()))
            {
                Customer savedCustomer = null;
                testData.Batch(x => savedCustomer = x.GetCustomerById(customer.CustomerID));
                Assert.IsNotNull(savedCustomer);
                Assert.AreEqual(savedCustomer.LastName, "Changed");
            }
        }

        public void Test_Updating_Money_Amount_Updates_Amount_In_Store_And_Returns_Updated_Figure()
        {
            var newAmount = (decimal) new Random().Next();
            using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
            {
                testData.Batch(actions => actions.CreateMonthlySalesSummaryForSalesPerson(1));

                using (var scope = new UnitOfWorkScope())
                {
                    var repository = new NHRepository<MonthlySalesSummary>();
                    var report = (from summary in repository
                                  where summary.SalesPersonId == 1
                                  select summary).SingleOrDefault();
                    report.TotalSale.Amount = newAmount;
                    scope.Commit();
                }

                using (var scope = new UnitOfWorkScope())
                {
                    var repository = new NHRepository<MonthlySalesSummary>();
                    var report = (from summary in repository
                                  where summary.SalesPersonId == 1
                                  select summary).SingleOrDefault();

                    Assert.That(report.TotalSale.Amount, Is.EqualTo(newAmount));
                    scope.Commit();
                }
            }
        }

        public void Test_Can_Query_MonthlySalesSummary_Based_On_Currency()
        {
            IList<MonthlySalesSummary> report;
            using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
            using (var scope = new UnitOfWorkScope())
            {
                testData.Batch(actions => actions.CreateMonthlySalesSummaryWithAmount(
                    new Money{Amount = 100, Currency = "YEN"}
                    ));

                var repository = new NHRepository<MonthlySalesSummary>();
                report = (from summary in repository
                          where summary.TotalSale.Currency == "YEN"
                          select summary).ToList();

                scope.Commit();
            }

            Assert.That(report, Is.Not.Null);
            Assert.That(report.Count, Is.GreaterThan(0));

            report.ForEach(rep =>
            {
                Assert.That(rep.TotalSale, Is.Not.Null);
                Assert.That(rep.TotalSale.Amount, Is.GreaterThan(0));
                Assert.That(rep.TotalSale.Currency, Is.Not.Null);
                Assert.That(rep.TotalSale.Currency, Is.EqualTo("YEN"));
            });
        }

        public void Test_Can_Get_MonthlySalesSummary_With_Money_Type()
        {
            IList<MonthlySalesSummary> report;
            using (var testData = new NHTestDataGenerator(Factory.OpenSession()))
            using (var scope = new UnitOfWorkScope())
            {
                testData.Batch(action => action.CreateMonthlySalesSummaryForMonth(1));

                var repository = new NHRepository<MonthlySalesSummary>();
                report = (from summary in repository
                          where summary.Month == 1
                          select summary).ToList();

                scope.Commit();
            }

            Assert.That(report, Is.Not.Null);
            Assert.That(report.Count, Is.GreaterThan(0));

            report.ForEach(rep =>
                               {
                                   Assert.That(rep.Month == 1);
                                   Assert.That(rep.TotalSale, Is.Not.Null);
                                   Assert.That(rep.TotalSale.Amount, Is.GreaterThan(0));
                                   Assert.That(rep.TotalSale.Currency, Is.Not.Null);
                               });
        }

        protected void btnGenerate_Click(object sender, DirectEventArgs e)
        {
            using (var unitOfWork = new UnitOfWorkScope(true))
            {
                BusinessLogic.GenerateBillFacade.GenerateReceivable(dtGenerationDate.SelectedDate);
            }
            using (var unitOfWork = new UnitOfWorkScope(true))
            {

                LoanAccount.UpdateLoanAccountStatus(dtGenerationDate.SelectedDate);
            }
            using (var unitOfWork = new UnitOfWorkScope(true))
            {
                DemandLetter.UpdateDemandLetterStatus(dtGenerationDate.SelectedDate);
            }
            using (var unitOfWork = new UnitOfWorkScope(true))
            {
                Customer.UpdateCustomerStatus(dtGenerationDate.SelectedDate);
            }
            using (var unitOfWork = new UnitOfWorkScope(true))
            {

                FinancialProduct.UpdateStatus();

            }
        }

        public void Can_eager_fetch_many()
        {
            var testData = new EFTestData(Context);

            Customer customer = null;
            Customer savedCustomer = null;
            testData.Batch(x =>
            {
                customer = x.CreateCustomer();
                var order = x.CreateOrderForCustomer(customer);
                order.OrderItems.Add(x.CreateOrderItem(item => item.Order = order));
                order.OrderItems.Add(x.CreateOrderItem(item => item.Order = order));
                order.OrderItems.Add(x.CreateOrderItem(item => item.Order = order));
            });

            using (var scope = new UnitOfWorkScope())
            {
                savedCustomer = new EFRepository<Customer,int>()
                    .FetchMany(x => x.Orders)
                    .ThenFetchMany(x => x.OrderItems)
                    .ThenFetch(x => x.Product).Query
                    .Where(x => x.CustomerID == customer.CustomerID)
                    .SingleOrDefault();
                scope.Commit();
            }

            Assert.IsNotNull(savedCustomer);
            Assert.IsNotNull(savedCustomer.Orders);
            savedCustomer.Orders.ForEach(order =>
            {
                Assert.IsNotNull(order.OrderItems);
                order.OrderItems.ForEach(orderItem => Assert.IsNotNull(orderItem.Product));
            });
        }

 public bool ChangeToZero(int loanid)
 {
     using (var unitOfWork = new UnitOfWorkScope(true))
     {
         return ChangeInterestTypeFacade.SaveInterestType(loanid, InterestType.ZeroInterestTYpe, 0);
     }
 }

public static Entities.Car GetCar(int id)
{
    using (var uow = new UnitOfWorkScope<CarsContext>(UnitOfWorkScopePurpose.Reading))
    {
        return uow.DbContext.Cars.Single(c => c.CarId == id);
    }
}

        public void TestInitialize()
        {
            _scope = new UnitOfWorkScope(new EFUnitOfWorkFactory(() => new DataContainer()));

            basicInfoDomainServiceObjects = new BasicInfoDomainServiceObjectsContainer(_scope);

            OrderConfigurator orderConfigurator = null;
            //new OrderConfigurator(new OrderStateFactory(new FuelReportDomainService(new FuelReportRepository(_scope),
            //    new VoyageDomainService( new VoyageRepository(_scope)),new InventoryOperationDomainService(new InventoryOperationRepository(_scope)),
            //    new InventoryOperationRepository(_scope),new InventoryOperationFactory()   ),new InvoiceDomainService() ));

            var client = new WebClientHelper(new HttpClient());
            _orderRepository = new OrderRepository(_scope, orderConfigurator, new EFRepository<OrderItem>(_scope));
            _orderRepository.GetAll();
            _tr = new TransactionScope();

            var hostAdapter = new ExternalHostAddressHelper();

            _target = new GoodFacadeService(
                new GoodDomainService(
                    new GoodAntiCorruptionAdapter(
                        new GoodAntiCorruptionServiceWrapper
                    (client, hostAdapter),
                    new GoodAntiCorruptionMapper()),
                    new EFRepository<Good>(_scope),
                    basicInfoDomainServiceObjects.CompanyDomainService, new EFRepository<GoodUnit>(_scope)),
                    new GoodToGoodDtoMapper(new CompanyGoodUnitToGoodUnitDtoMapper()));
        }

        public void can_commit_multiple_db_operations()
        {
            var customer = new Customer { FirstName = "John", LastName = "Doe" };
            var salesPerson = new SalesPerson { FirstName = "Jane", LastName = "Doe", SalesQuota = 2000 };

            using (var scope = new UnitOfWorkScope())
            {
                new EFRepository<Customer>().Add(customer);
                new EFRepository<SalesPerson>().Add(salesPerson);
                scope.Commit();
            }

            using (var ordersTestData = new EFTestData(OrdersContextProvider()))
            using (var hrTestData = new EFTestData(HRContextProvider()))
            {
                Customer savedCustomer = null;
                SalesPerson savedSalesPerson = null;
                ordersTestData.Batch(action => savedCustomer = action.GetCustomerById(customer.CustomerID));
                hrTestData.Batch(action => savedSalesPerson = action.GetSalesPersonById(salesPerson.Id));

                Assert.That(savedCustomer, Is.Not.Null);
                Assert.That(savedSalesPerson, Is.Not.Null);
                Assert.That(savedCustomer.CustomerID, Is.EqualTo(customer.CustomerID));
                Assert.That(savedSalesPerson.Id, Is.EqualTo(salesPerson.Id));
            }
        }

 public virtual void ChangePassword(Guid id, string oldPassword, string newPassword)
 {
     using (var scope = new UnitOfWorkScope())
     {
         _userAccountService.ChangePassword(id,oldPassword,newPassword);
         scope.Commit();
     }
 }

 public void CancelVerification(string key, out bool accountClosed)
 {
     using (var scope = new UnitOfWorkScope())
     {
         _userAccountService.CancelVerification(key,out accountClosed);
         scope.Commit();
     }
 }

        public void TestInitialize()
        {
            _scope = new UnitOfWorkScope(new EFUnitOfWorkFactory(() => new DataContainer()));

            _orderRepository = null;//new OrderRepository(_scope, new OrderConfigurator(new StateFactory(new )), new EFRepository<OrderItem>(_scope));
            _orderRepository.GetAll();

            _target = new OrderDomainService(_orderRepository);
        }

 protected void btnDeactivate_Click(object sender, DirectEventArgs e)
 {
     FinancialProductForm form = this.CreateOrRetrieve<FinancialProductForm>();
     using (var unitOfWork = new UnitOfWorkScope(true))
     {
         ProductStatu status = ProductStatu.ChangeStatus(form.FinancialProductId, ProductStatusType.InactiveType, DateTime.Now);
         EnableValidActivity(status);
     }
 }

        protected void btnSave_Click(object sender, DirectEventArgs e)
        {
            var today = DateTime.Now;

            using (var unitOfWork = new UnitOfWorkScope())
            {
                LoanRestructureForm form = this.CreateOrRetrieve<LoanRestructureForm>();
                form.SaveChangeIcmAmortizationSchedule(today);
            }
        }

 protected void btnSave_Click(object sender, DirectEventArgs e)
 {
     using (var unitOfWork = new UnitOfWorkScope(true))
     {
         int id = int.Parse(this.RecordID.Text);
         AssetType asset = ObjectContext.AssetTypes.SingleOrDefault(entity => entity.Id == id);
         asset.Name = this.txtName.Text;
         asset.IsAppraisableIndicator = this.radTrue.Checked;
     }
 }

 public bool ChangeToFixed(int loanid)
 {
     decimal amount = 0;
     if (string.IsNullOrWhiteSpace(txtInterest.Text) == false)
         amount = decimal.Parse(txtInterest.Text);
     using (var unitOfWork = new UnitOfWorkScope(true))
     {
         return ChangeInterestTypeFacade.SaveInterestType(loanid, InterestType.FixedInterestTYpe, amount);
     }
 }

 public bool ChangePasswordFromResetKey(string key, string newPassword, out NhUserAccount account)
 {
     bool success;
     using (var scope = new UnitOfWorkScope())
     {
         success=_userAccountService.ChangePasswordFromResetKey(key,newPassword,out account);
         scope.Commit();
     }
     return success;
 }

        public virtual void AddUsersToRoles(List<Guid> userId, List<string> roleName)
        {
            if (userId == null || userId.Count == 0 || roleName == null || roleName.Count == 0)
                return;
            StringBuilder message=new StringBuilder();
            var users = _userRepository.Query.Where(x => userId.Contains(x.ID)).ToList();
            var roles = _roleRepository.Query.Where(x => roleName.Contains(x.Name)).ToList();
            foreach (var userEntity in users)
            {
                if (userEntity.Roles != null && userEntity.Roles.Any())
                {
                    var newRoles = roles.Except(userEntity.Roles);

                    foreach (var role in newRoles)
                        userEntity.Roles.Add(role);
                    if(newRoles!=null && newRoles.Count()>0)
                        message.AppendFormat("User {0} is added to role(s) {1}.",userEntity.Username,string.Join(",", newRoles.Select(x => x.Name)));
                }
                else
                {
                    foreach (var role in roles)
                        userEntity.Roles.Add(role);
                    if(roles!=null && roles.Count()>0)
                        message.AppendFormat("User {0} is added to role(s) {1}.",userEntity.Username,string.Join(",", roles.Select(x => x.Name)));
                }
                using (var scope = new UnitOfWorkScope())
                {
                    _userRepository.Update(userEntity);
                    scope.Commit();
                }
            }
            foreach (var uid in userId)
            {
                if (!users.Any(u => u.ID == uid))
                {
                    var user = _userRepository.Query.Where(x => x.ID == uid).SingleOrDefault();
                    if (user != null)
                    {
                        user.Roles = roles;
                        using (var scope = new UnitOfWorkScope())
                        {
                            _userRepository.Update(user);
                            scope.Commit();
                        }
                        if(roles!=null && roles.Count()>0)
                            message.AppendFormat("User {0} is added to role(s) {1}.",user.Username,string.Join(",", roles.Select(x => x.Name)));
                    }
                }
            }
            if (message.Length > 0)
            {
                ActivityLog item = new ActivityLog(ActivityType.AddUserToRole.ToString(), message.ToString());
                _activityLogService.Add(item);
            }
        }