public void Test_Create_Child_ActivityDetail()
{
ChildActivityDetail cg = new ChildActivityDetail()
{
EventDate = DateTime.Today,
StartTime = DateTime.Now,
Child = new ChildDetail()
{
Key = 1
},
Activity = new ChildActivityType()
{
Key = 3
}
};
NHibernateRepository ds = new NHibernateRepository(_sessionFactory);
using (ctx = ctx.Start())
{
ctx.BeginTransaction();
ds.Add(cg);
ctx.Commit();
Console.WriteLine(cg.Key);
Assert.That(cg.Key > 0);
}
}
protected void InsertTestEntity(string name)
{
var testEntityRepository = new NHibernateRepository<TestEntity>();
var testEntity = new TestEntity { Name = name };
testEntityRepository.SaveOrUpdate(testEntity);
NHibernateSession.Current.Evict(testEntity);
}
public void SetUp()
{
_uow = MockRepository.GenerateMock<INHibernateUnitOfWork>();
_session = MockRepository.GenerateMock<ISession>();
_uow.Stub(u => u.CurrentSession).Return(_session);
_repo = new NHibernateRepository<Guid>(_uow);
}
public void Init()
{
using (var session = SessionManager.BuildSessionFactory().OpenSession())
{
using (var tx = session.BeginTransaction())
{
IRepository repository = new NHibernateRepository(session);
var admin = repository.Query<User>()
.FirstOrDefault(u => u.Username == "admin") ?? new User();
admin.Username = "******";
admin.Password = "******";
admin.Email = "*****@*****.**";
admin.Role = "admin";
repository.Save(admin);
var anon = repository.Query<User>()
.FirstOrDefault(u => u.Username == "anonymous") ?? new User();
anon.Username = "******";
anon.Password = "";
anon.Role = "user";
repository.Save(anon);
tx.Commit();
}
session.Close();
}
}
public void AddsArrayOfElementsToTheRepository()
{
//// SETUP
var testEntities = new List<TestEntity>
{
new TestEntity { Name = "One" },
new TestEntity { Name = "Two" },
new TestEntity { Name = "Three" }
};
using (var session = GetInMemoryDatabaseSession())
{
// Mock session factory that will provide the in-memory session.
var mockSessionFactory = new Mock<ISessionFactory>();
mockSessionFactory.Setup(mock => mock.OpenSession()).Returns(session);
// Setup target
var target = new NHibernateRepository<TestEntity>(mockSessionFactory.Object);
// EXECUTE
var result = target.Add(testEntities);
//// VERIFY
var query = session.Query<TestEntity>();
Assert.True(result);
Assert.AreEqual(testEntities.Count, query.Count());
foreach (var entity in testEntities)
{
Assert.True(query.Contains(entity));
}
}
}
public void Can_Change_A_Saved_Post()
{
var newPost = new Post()
{
Body = "Corpo do post!",
Title = "Titulo do post",
Slug = "Titulo do post".Slugify(),
Author = "Renata Fan"
};
var repository = new NHibernateRepository<Post>(SessionFactory, null);
repository.Add(newPost);
Session.Flush();
Post saved = repository.FirstOrDefault(c => c.Id == newPost.Id);
saved.Title += "Changed";
saved.Body += "Changed";
saved.Slug += saved.Title.Slugify();
Session.Flush();
Assert.AreEqual("Corpo do post!Changed", saved.Body);
Assert.AreEqual("Titulo do postChanged", saved.Title);
}
public void Constructors()
{
Assert.Throws<ArgumentNullException>(() => new NHibernateRepository<TestEntity>((ISessionFactory) null));
Assert.Throws<ArgumentNullException>(() => new NHibernateRepository<TestEntity>((Configuration)null));
using (var sessionFactory = this.configuration.BuildSessionFactory())
{
var session = sessionFactory.OpenSession();
using (var repository = new NHibernateRepository<TestEntity>(session))
{
Assert.True(ReferenceEquals(sessionFactory, session.SessionFactory));
Assert.Equal(FlushMode.Never, session.FlushMode);
Assert.False(repository.Field("ownsSession").To<bool>());
}
session.Dispose();
using (var repository = new NHibernateRepository<TestEntity>(sessionFactory))
{
session = repository.Session;
Assert.True(ReferenceEquals(sessionFactory, session.SessionFactory));
Assert.Equal(FlushMode.Never, session.FlushMode);
Assert.True(repository.Field("ownsSession").To<bool>());
}
using (var repository = new NHibernateRepository<TestEntity>(this.configuration))
{
session = repository.Session;
Assert.False(ReferenceEquals(sessionFactory, session.SessionFactory));
Assert.Equal(FlushMode.Never, session.FlushMode);
Assert.True(repository.Field("ownsSession").To<bool>());
}
}
}
public void Can_Comment_A_Saved_Post()
{
var newPost = new Post()
{
Body = "Corpo do post!",
Title = "Titulo do post",
Slug = "Titulo do post".Slugify(),
Author = "Renata Fan"
};
var repository = new NHibernateRepository<Post>(SessionFactory, null);
repository.Add(newPost);
Session.Flush();
Post saved = repository.FirstOrDefault(c => c.Id == newPost.Id);
saved.Comment("Eeeeeeeeeeeu!", "Chapolin", "*****@*****.**");
Session.Flush();
Assert.AreEqual(1, saved.Comments.Count());
Assert.AreEqual("Chapolin", saved.Comments.FirstOrDefault().Author);
Assert.AreEqual("Eeeeeeeeeeeu!", saved.Comments.FirstOrDefault().Text);
Assert.AreEqual("*****@*****.**", saved.Comments.FirstOrDefault().Mail);
}
static void Main(string[] args)
{
var flagRepostory= new NHibernateRepository<Flag>();
var langRepository = new NHibernateRepository<Language>();
var langInfoRepository= new NHibernateRepository<LanguageInfo>();
//var langInfo = langInfoRepository.GetAll();
var flags = flagRepostory.GetAll();
//var lang = langRepository.Get(2);
//LanguageInfo langInfo = new LanguageInfo();
//langInfo.LongPath = "test";
//langInfo.ShortPath = "test1";
//langInfo.AddLanguage(lang);
//lang.AddLanguageIcon(langInfo);
//langRepository.Save(lang);
//langInfoRepository.Save(langInfo);
Flag flag = new Flag();
flag.Name = " F*****g programe";
flag.Description = " Flag Descrption2";
var lang = langRepository.Get(2);
var languageInfo = new LanguageInfoNew { LongPath = "@C:Test1", ShortPath = "@d:tet2" };
languageInfo.AddLanguage(lang);
//lang.AddLanguageIcon(new LanguageInfo { LongPath = "Test1", ShortPath = "test1" });
flag.AddLanguage(languageInfo);
flagRepostory.Save(flag);
}
public void Can_Get_Posts_First_Page_By_Author_Name()
{
var mockServiceLocator = new Mock<IServiceLocator>();
mockServiceLocator
.Setup(c => c.GetInstance<IPagedPostSearch>())
.Returns(new PagedPostSearch(SessionFactory))
.Verifiable();
IServiceLocator serviceLocator = mockServiceLocator.Object;
var repository = new NHibernateRepository<Post>(SessionFactory, new QueryFactory(serviceLocator));
LoadPosts(repository);
var query = repository.CreateQuery<IPagedPostSearch>();
query.ItemsPerPage = 5;
query.PageNumber = 1;
query.AuthorName = "Renata Fan";
PagedResult<Post> posts = query.Execute();
Assert.AreEqual(5, posts.TotalItems);
Assert.AreEqual(5, posts.PageOfResults.Count());
mockServiceLocator.VerifyAll();
}
public void First_we_need_a_schema_to_test()
{
var schemaExport = new SchemaExport(_cfg);
schemaExport.Drop(true, true);
schemaExport.Create(true, true);
try
{
using (IUnitOfWork work = UnitOfWork.Start())
using (ITransaction transaction = work.BeginTransaction(IsolationLevel.Serializable))
{
using (var repository = new NHibernateRepository())
{
repository.Save(new TestSaga(_sagaId) { Name = "Joe" });
repository.Save(new TestSaga(CombGuid.Generate()) { Name = "Chris" });
work.Flush();
transaction.Commit();
}
}
}
finally
{
UnitOfWork.Finish();
}
}
public void PlaceOrder(Order order)
{
var repository = new NHibernateRepository<Order>();
var notifier = new PlainTextEmailer();
repository.Save(order);
notifier.Send(order.Customer, "Your order was successfully processed.");
}
protected override void LoadTestData()
{
var repository = new NHibernateRepository<Product>();
for (var id = 1; id <= 100; ++id) {
var name = string.Format("Product {0:d3}", id);
var product = new Product { ProductName = name };
repository.Save(product);
}
}
public void Can_Select_Posts_By_Author_Name()
{
var repository = new NHibernateRepository<Post>(SessionFactory, null);
LoadPosts(repository);
IEnumerable<Post> posts = repository.FindAll(new PostCreatedBy("Renata Fan"));
Assert.AreEqual(10, posts.Count());
}
public void Can_Select_Posts_By_Author_Name()
{
var repository = new NHibernateRepository<Post>(SessionFactory, null);
LoadPosts(repository);
IEnumerable<Post> posts =
repository.FindAll(new GenericSpecification<Post>(c => c.Author.Contains("Renata Fan")));
Assert.AreEqual(10, posts.Count());
}
public void Can_Select_One_Post_By_Title()
{
var repository = new NHibernateRepository<Post>(SessionFactory, null);
LoadPosts(repository);
Post post = repository.FindOne(new GenericSpecification<Post>(c => c.Title == "Title1"));
Assert.AreEqual("Title1", post.Title);
Assert.AreEqual("Body1", post.Body);
Assert.AreEqual("Renata Fan", post.Author);
}
/// <summary>
/// In the test fixture setup I simply ovveride the configuration registry
/// using an in memory configuration with a fixed connection string.
/// </summary>
protected override void OnTestFixtureSetUp()
{
sut = new NHibernateRepository<AnEntity>();
sut.ConfigurationFileName = ConfigFileName;
repo = new InMemoryConfigurationRegistry();
repo.ConnStrings.Add(
"main", new ConnectionStringSettings(
"main", "Data Source=DbFile1.db;Version=3", "System.Data.SQLite"));
DisposeAtTheEndOfFixture(ConfigurationRegistry.Override(repo));
NHibernateSessionManager.GenerateDbFor(ConfigFileName);
base.OnTestFixtureSetUp();
}
private static LMConnect.Key.User OnValidationDelegate(string userName, string password)
{
using (ISession session = MvcApplication.SessionFactory.OpenSession())
{
var repo = new NHibernateRepository(session);
var user = repo.Query<LMConnect.Key.User>()
.FirstOrDefault(u => u.Username == userName && u.Password == password);
session.Close();
return user;
}
}
public void SaveCustomer()
{
Customer customer = null;
//create a session provide, provide the current database session
ISessionProvider sessionProvider = new SessionProvider();
//a generic repository that handles saving the entity to
// the database
NHibernateRepository<Customer> customerRepository =
new NHibernateRepository<Customer>(sessionProvider);
//save the customer to the database
customerRepository.Save(customer);
}
public void CanReturnSingleRecentItem()
{
// save a prod
var ciRep = new NHibernateRepository<CharityInfo>();
var ci = new CharityInfo();
ci.CharityName = "testprod";
ciRep.SaveOrUpdate(ci);
int savedId = ci.Id;
this.FlushSessionAndEvict(ci);
var ciRep2 = new NHibernateRepository<CharityInfo>();
var foundProd = ciRep2.Get(savedId);
Assert.AreEqual("testprod", foundProd.CharityName);
}
private void LoadPosts(NHibernateRepository<Post> repository)
{
for (int i = 0; i < 10; i++)
{
var post = new Post()
{
Body = "Body" + i,
Title = "Title" + i,
Slug = ("Title" + i).Slugify(),
Author = "Renata Fan"
};
repository.Add(post);
}
Session.Flush();
}
public void Commit_Method()
{
var entity = new TestEntity();
using (var repository = new NHibernateRepository<TestEntity>(this.configuration))
{
Assert.False(repository.Any());
Assert.True(ReferenceEquals(repository.Persist(entity).Commit(), repository));
Assert.True(ReferenceEquals(repository.Single(), entity));
repository.Delete(entity);
Assert.True(ReferenceEquals(repository.Single(), entity));
repository.Commit();
Assert.False(repository.Any());
}
}
static void Main(string[] args)
{
var order = new Order
{
Decription = "iPhone 4",
Quantity = 1,
Customer = new Customer
{
Name = "Andy Pike",
Email = "*****@*****.**",
Phone = "1234567890"
}
};
var repository = new NHibernateRepository<Order>(new FileLogger());
var notifier = new PlainTextEmailer();
var orderProcessingService = new OrderProcessingService(repository, notifier);
orderProcessingService.PlaceOrder(order);
}
public void IntegrationTest()
{
IList<Banana> bananas = new List<Banana>();
bananas.Add(new Banana() { Color = "Brown" });
bananas.Add(new Banana() { Color = "Yellow" });
IRepository<Banana> bRepo = new NHibernateRepository<Banana>();
foreach (Banana b in bananas)
bRepo.Save(b);
Assert.IsTrue(bRepo.GetAll().Count == bananas.Count);
IList<Monkey> monkeys = new List<Monkey>();
monkeys.Add(new Monkey() { Name = "George", FlingsPoo = true, Bananas = bananas });
monkeys.Add(new Monkey() { Name = "Magilla", FlingsPoo = false });
IRepository<Monkey> mRepo = new NHibernateRepository<Monkey>();
foreach (Monkey m in monkeys)
mRepo.Save(m);
Assert.IsTrue(mRepo.GetAll().Count == monkeys.Count);
Monkey tempMonkey;
tempMonkey = mRepo.Get(monkeys[0].Id);
Assert.IsNotNull(tempMonkey);
tempMonkey = mRepo.Get(-1);
Assert.IsNull(tempMonkey);
IMonkeyRepository imRepo = new MonkeyRepository();
Assert.IsTrue(imRepo.GetPooFlingingMonkeys().Count == 1);
foreach (Banana b in bananas)
bRepo.Delete(b);
Assert.IsTrue(bRepo.GetAll().Count == 0);
foreach (Monkey m in monkeys)
mRepo.Delete(m);
Assert.IsTrue(mRepo.GetAll().Count == 0);
}
public void Can_Create_A_New_Post()
{
var newPost = new Post()
{
Body = "Corpo do post!",
Title = "Titulo do post",
Slug = "Titulo do post".Slugify(),
Author = "Renata Fan"
};
var repository = new NHibernateRepository<Post>(SessionFactory, null);
repository.Add(newPost);
Session.Flush();
Assert.IsNotNull(newPost.Id);
Assert.IsTrue(newPost.CreatedAt.IsToday());
Assert.AreEqual("Corpo do post!", newPost.Body);
Assert.AreEqual("Titulo do post", newPost.Title);
Assert.AreEqual("Renata Fan", newPost.Author);
}
public void GenerateSchemaAndData()
{
var cfg = new global::NHibernate.Cfg.Configuration().Configure();
new SchemaExport(cfg)
.SetDelimiter(";")
.Execute(false, true, false);
var random = new Random();
Func<DateTime> before2000 = () => new DateTime(random.Next(1950, 2000), random.Next(1, 13), random.Next(1, 29));
Func<DateTime> before2005 = () => new DateTime(random.Next(2000, 2005), random.Next(1, 13), random.Next(1, 29));
//some user data
var users = new[] {
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User {Created = DateTime.Now, Email = "*****@*****.**", Username = "******" },
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2000(), Email = "*****@*****.**", Username = "******" },
new User { Email = "*****@*****.**", Username = "******" },
new User { Email = "*****@*****.**", Username = "******" },
new User { Email = "*****@*****.**", Username = "******" },
new User { Email = "*****@*****.**", Username = "******" },
new User {Created = before2005(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2005(), Email = "*****@*****.**", Username = "******" },
new User {Created = before2005(), Email = "*****@*****.**", Username = "******" },
new User { Email = "*****@*****.**", Username = "******" },
};
using (var sessionFactory = cfg.BuildSessionFactory()) {
using (var session = sessionFactory.OpenSession()) {
using (var tx = session.BeginTransaction()) {
var repo = new NHibernateRepository<User>(session);
users.Walk(user => repo.Save(user));
tx.Commit();
}
}
}
}
public void Saving_a_state_machine_should_work()
{
Guid transactionId;
using (var unitOfWork = UnitOfWork.Start())
using (var transaction = unitOfWork.BeginTransaction(IsolationLevel.Serializable))
{
using(var repository = new NHibernateRepository() )
{
ExampleStateMachine machine = new ExampleStateMachine();
repository.Save(machine);
transactionId = machine.TransactionId;
}
transaction.Commit();
}
UnitOfWork.Finish();
using (var unitOfWork = UnitOfWork.Start())
using (var transaction = unitOfWork.BeginTransaction(IsolationLevel.Serializable))
{
using (var repository = new NHibernateRepository())
{
ExampleStateMachine machine = repository.Get<ExampleStateMachine>(transactionId);
machine.SubmitOrder();
repository.Update(machine);
}
transaction.Commit();
}
UnitOfWork.Finish();
}
public void Can_Search_By_Post_Title()
{
var mockServiceLocator = new Mock<IServiceLocator>();
mockServiceLocator
.Setup(c => c.GetInstance<IAdvancedPostSearch>())
.Returns(new AdvancedPostSearch(SessionFactory))
.Verifiable();
IServiceLocator serviceLocator = mockServiceLocator.Object;
var repository = new NHibernateRepository<Post>(SessionFactory, new QueryFactory(serviceLocator));
LoadPosts(repository);
var query = repository.CreateQuery<IAdvancedPostSearch>();
query.Title = "Title1";
IEnumerable<Post> posts = query.Execute();
Assert.AreEqual(1, posts.Count());
mockServiceLocator.VerifyAll();
}
public PersistantDeferredMessageRepository(NHibernateRepository repository)
{
_repository = repository;
}
public void Delete_Method()
{
Assert.Throws<ArgumentNullException>(() => new NHibernateRepository<TestEntity>(this.configuration).Delete(null));
var entity = new TestEntity();
using (var repository = new NHibernateRepository<TestEntity>(this.configuration))
{
repository.Transaction(() => Assert.True(ReferenceEquals(repository.Delete(entity), repository)));
repository.Transaction(() => repository.Persist(entity));
repository.Transaction(() => repository.Delete(new TestEntity()));
Assert.True(ReferenceEquals(repository.Single(), entity));
repository.Transaction(() => repository.Delete(entity));
Assert.False(repository.Any());
}
}
static void Main(string[] args)
{
Console.WriteLine("Getting configuration ...");
var connectionString
= ConfigurationManager.ConnectionStrings ["AspSQLProvider"].ToString();
Console.WriteLine("ConnectionString: " + connectionString);
// Delete and recreate db
Console.WriteLine("Tying to delete database ...");
var pDropDb = Process.Start("/usr/bin/dropdb", "mvcstore");
pDropDb.WaitForExit();
Console.WriteLine();
Console.WriteLine("Trying to create database ...");
var pCreateDb = Process.Start("/usr/bin/createdb", "mvcstore");
pCreateDb.WaitForExit();
Console.WriteLine();
// setup store schema
Console.WriteLine("Setting up store schema ...");
MvcStoreApplication.InitDb(connectionString, true);
Console.WriteLine();
// loading dummy data into store schema
Console.WriteLine("Loading dummy data into store schema ...");
var pLoadData = Process.Start("/usr/bin/psql", DbName + " -f populatedb.sql");
pLoadData.WaitForExit();
Console.WriteLine();
// loading product images into db
var picgen = new PictureGenerator {
Size = 250
};
var repo = new NHibernateRepository <Product> ();
foreach (var item in repo.GetItems())
{
item.Image = picgen.Next();
repo.UpdateItem(item);
}
// setup membership schema
Console.WriteLine("Setting up membership schema ...");
var pExeMemSchema = Process.Start("/usr/bin/psql",
DbName + " -f DatabaseSchema.sql");
pExeMemSchema.WaitForExit();
Console.WriteLine();
// setup membership admin role and user
Console.WriteLine("Setting up membership admin ...");
var pExeMemAdmin = Process.Start("/usr/bin/psql",
DbName + " -f MembershipRolesSetup.sql");
pExeMemAdmin.WaitForExit();
Console.WriteLine();
Console.WriteLine("Complete.");
}
public HibernatedController(NHibernateRepository repository)
{
_repository = repository;
}
/// <inheritdoc />
public NHibernateRepositoryTests(NHibernateTestsSetup setup) : base(setup)
{
_repo = new NHibernateRepository <Contractor, int>(TransactionManager);
}
static void Main(string[] args)
{
//create tables from mapping
new SchemaExport(NHibernateHelper.Configuration).Create(false, true);
#region use_inline
//open connection to db
using (ISession session = NHibernateHelper.SessionFactory.OpenSession())
{
#region add
using (ITransaction tx = session.BeginTransaction())
{
for (int i = 0; i < 30; i++)
{
var employee = new Employee {
Name = new Name {
FirstName = "Employee", LastName = string.Format("{0}", i)
}
};
var employer = new Employer {
Name = string.Format("Employer {0}", i)
};
var employment = new Employment
{
Employee = employee,
Employer = employer,
StartDate = System.DateTime.Now,
EndDate = System.DateTime.Now.AddDays(i)
};
session.Save(employee);
session.Save(employer);
session.Save(employment);
}
tx.Commit();
}
#endregion
#region list
using (var tx = session.BeginTransaction())
{
//dont forget ToList()
var employments = session.Query <Employment>().ToList();
foreach (var employment in employments)
{
Console.Out.WriteLine("Employee: " + employment.Employee.Name.LastName + " end date " + employment.EndDate + " at employer " + employment.Employer.Name);
}
tx.Commit();
}
#endregion
}
#endregion
#region using_repository
IRepository <Employment> EmploymentRepository = new NHibernateRepository <Employment>();
IRepository <Employee> EmployeeRepository = new NHibernateRepository <Employee>();
IRepository <Employer> EmployerRepository = new NHibernateRepository <Employer>();
#region add
for (int i = 0; i < 30; i++)
{
var employee = new Employee {
Name = new Name {
FirstName = "Employee", LastName = string.Format("{0}", i)
}
};
var employer = new Employer {
Name = string.Format("Employer {0}", i)
};
var employment = new Employment
{
Employee = employee,
Employer = employer,
StartDate = System.DateTime.Now,
EndDate = System.DateTime.Now.AddDays(i)
};
EmployeeRepository.Save(employee);
EmployerRepository.Save(employer);
EmploymentRepository.Save(employment);
}
#endregion
#region show
foreach (var employment in EmploymentRepository.GetAll())
{
Console.Out.WriteLine("Employee: " + employment.Employee.Name.LastName + " end date " + employment.EndDate + " at employer " + employment.Employer.Name);
}
#endregion
#endregion
}
internal StudentDal(ISession session)
{
repository = new NHibernateRepository <StudentEntity>(session);
}
internal ApplicationDal(ISession session)
{
repository = new NHibernateRepository <ApplicationEntity>(session);
}
public void TestMapping()
{
var test = new NHibernateRepository <Subscription>(new NhibernateUnitOfWork()).GetAll();
}
public void PutSomeDataTest()
{
var sessionFactory = DataBase.CreateSessionFactory();
using (var session = sessionFactory.OpenSession())
{
var songTypeRepository = new NHibernateRepository <SongType, int>(session);
var rockSongType = new SongType()
{
Name = "Rock"
};
var popSongType = new SongType()
{
Name = "Pop"
};
songTypeRepository.Create(rockSongType);
songTypeRepository.Create(popSongType);
var songRepository = new NHibernateRepository <Song, string>(session);
songRepository.Create(new Song()
{
Title = "Last Christmas",
Type = popSongType,
Chords = "G D C a G",
Scale = "G"
});
songRepository.Create(new Song()
{
Title = "You're simply the best",
Type = rockSongType,
Chords = "F B d B F",
Scale = "F"
});
songRepository.Create(new Song()
{
Title = "Zostańmy razem",
Type = rockSongType,
Chords = "B Es d B F",
Scale = "B"
});
songRepository.Create(new Song()
{
Title = "Kocham Cie",
Type = rockSongType,
Chords = "G D a D C G",
Scale = "G"
});
var agreement = new Agreement()
{
Name = "Agnieszka Pasternak",
Address = "Tomaszów Mazowiecki, ul. Nadpiliczna",
Amount = 5000,
Signed = true,
StartTime = new DateTime(2010, 1, 1),
TimeStamp = DateTime.UtcNow,
City = "Tomaszów Mazowiecki",
DownPayment = 1000,
Member = "Grzegorz Pasternak",
Phone = "707345555",
Place = "Zajazd",
Remarks = "Don't be late"
};
var agreementRepository = new NHibernateRepository <Agreement, int>(session);
agreementRepository.Create(agreement);
session.Flush();
}
}
public PersistantDeferredMessageRepository(NHibernateRepository repository)
{
_repository = repository;
}
public void TestMapping()
{
var entity = new NHibernateRepository <Alternative>(new NhibernateUnitOfWork()).GetAll();
}
internal IndividualDal(ISession session)
{
repository = new NHibernateRepository <IndividualEntity>(session);
}
