public void Can_Save_BuildingManager_To_DB()
        {
            // Arrange
            LegalPerson legalPerson = new LegalPerson("12345678901", "Ime");
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            BuildingManagersNHRepository buildingManagersNhRepository = new BuildingManagersNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    buildingManagersNhRepository.SaveOrUpdate(buildingManager);
                    tx.Commit();
                }

            }

            IList<BuildingManager> managers = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    managers = buildingManagersNhRepository.GetAll().ToList();
                    tx.Commit();
                }

            }

            // Assert
            Assert.IsTrue(managers.Count > 0, "Contractor has been saved to database.");
        }
        public void Can_Save_Person_To_DB()
        {
            // Arrange
            PhysicalPerson physicalPerson = new PhysicalPerson("12345678901", "Ivo", "Ivic");
            LegalPerson legalPerson = new LegalPerson("12345678902", "FER");

            PersonsNHRepository personsNhRepository = new PersonsNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using(var tx = Session.BeginTransaction()) {
                    personsNhRepository.SaveOrUpdate(physicalPerson);
                    personsNhRepository.SaveOrUpdate(legalPerson);
                    tx.Commit();
                }

            }

            IList<Person> persons = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    persons = personsNhRepository.GetAll().ToList();
                    tx.Commit();
                }

            }

            // Assert
            Assert.IsTrue(persons.Contains(physicalPerson), "PhysicalPerson doesn't exists in database.");
            Assert.IsTrue(persons.Contains(legalPerson), "LegalPerson doesn't exists in database.");
        }
        public void Can_Remove_Service_From_Contractor()
        {
            LegalPerson legalPersonForContractor1 = new LegalPerson("12345678902", "Contractor 1 d.o.o.");
            Contractor contractor1 = new Contractor(legalPersonForContractor1);
            LegalPerson legalPersonForContractor2 = new LegalPerson("12345678903", "Contractor 2 d.o.o.");
            Contractor contractor2 = new Contractor(legalPersonForContractor2);
            LegalPerson legalPersonForContractor3 = new LegalPerson("12345678904", "Contractor 3 d.o.o.");
            Contractor contractor3 = new Contractor(legalPersonForContractor3);

            Contractor[] contractors = new Contractor[] {
                contractor1,
                contractor2,
                contractor3
            };

            LegalPerson legalPersonForManager = new LegalPerson("12345678901", "Mile d.o.o.");

            BuildingManager buildingManager = new BuildingManager(legalPersonForManager, contractors);

            // Act
            buildingManager.RemoveContractor(contractor2);

            // Assert
            Assert.AreEqual(2, buildingManager.Contractors.Count);
            Assert.AreEqual(contractor1, buildingManager.Contractors.ElementAt(0));
            Assert.AreEqual(contractor3, buildingManager.Contractors.ElementAt(1));
        }
        public static BuildingManager getBuildingManager()
        {
            LegalPerson legalPerson = new LegalPerson("12345678902", "Upravitelj");
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            return buildingManager;
        }
        public void BuildingManager_Can_Set_Cotractor_For_Maitenance()
        {
            // Arrange
            MaintenanceRequest maintenanceRequest = new MaintenanceRequest(person, "Kvar", "Ne radi grijanje.", "Stan Mile, prvi kat.");

            RepairService serviceTypeForMock = new RepairService("Ličenje");
            Mock<IRepairServicesRepository> repairServicesRepositoryMock = new Mock<IRepairServicesRepository>();
            repairServicesRepositoryMock.Setup(x => x.GetById(23)).Returns(serviceTypeForMock);

            RepairService serviceType = repairServicesRepositoryMock.Object.GetById(23);
            Maintenance maintenance = new Maintenance(maintenanceRequest, Urgency.High, serviceType, building);

            LegalPerson legalPerson = new LegalPerson("12345678901", "Mile d.o.o.");
            Contractor contractor = new Contractor(legalPerson).AddRepairService(serviceType);

            BuildingManager buildingManager = maintenance.BuildingManager;
            buildingManager.AddContractor(contractor);

            // Act
            maintenance.SetContractor(contractor);

            // Assert
            var personSnapshot = new PersonSnapshot(contractor.LegalPerson);
            Assert.IsNotNull(maintenance.Contractor);
            Assert.AreEqual(personSnapshot.Oib, maintenance.Contractor.Oib, "Oibs aren't equal.");
            Assert.AreEqual(personSnapshot.FullName, maintenance.Contractor.FullName, "FullNames aren't equal.");
            Assert.AreEqual(personSnapshot.Address, maintenance.Contractor.Address, "Addresses aren't equal.");
            Assert.AreEqual(personSnapshot, maintenance.Contractor);
        }
        public void Can_Add_Contractors_To_BuildingManager()
        {
            // Arrange
            LegalPerson legalPersonForContractor1 = new LegalPerson("12345678902", "Contractor 1 d.o.o.");
            Contractor contractor1 = new Contractor(legalPersonForContractor1);
            LegalPerson legalPersonForContractor2 = new LegalPerson("12345678903", "Contractor 2 d.o.o.");
            Contractor contractor2 = new Contractor(legalPersonForContractor2);

            Contractor[] contractors = new Contractor[] {
                contractor1,
                contractor2
            };

            LegalPerson legalPersonForContractor3 = new LegalPerson("12345678904", "Contractor 3 d.o.o.");
            Contractor contractor3 = new Contractor(legalPersonForContractor3);

            LegalPerson legalPersonForManager = new LegalPerson("12345678901", "Mile d.o.o.");

            // Act
            BuildingManager buildingManager = new BuildingManager(legalPersonForManager, contractors);
            buildingManager.AddContractor(contractor3);

            // Assert
            Assert.AreEqual(3, buildingManager.Contractors.Count);
            Assert.AreEqual(contractor1, buildingManager.Contractors.ElementAt(0));
            Assert.AreEqual(contractor2, buildingManager.Contractors.ElementAt(1));
            Assert.AreEqual(contractor3, buildingManager.Contractors.ElementAt(2));
        }
        public void Can_Save_Contractor_To_DB()
        {
            // Arrange
            LegalPerson legalPerson = new LegalPerson("12345678901", "Ime");
            Contractor contractor = new Contractor(legalPerson);

            ContractorsNHRepository contractorNhRepository = new ContractorsNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    contractorNhRepository.SaveOrUpdate(contractor);
                    tx.Commit();
                }

            }

            IList<Contractor> contractors = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    contractors = contractorNhRepository.GetAll().ToList();
                    tx.Commit();
                }

            }

            // Assert
            Assert.IsTrue(contractors.Count > 0, "Contractor has been saved to database.");
        }
        public void Can_Save_Bill_To_Db()
        {
            // Arrange
            City city = new City(10000, "Zagreb");
            Cadastre cadastre = new Cadastre("Trnje", "12345", city);
            CadastralParticle cadastralParticle = new CadastralParticle(cadastre, "123", 23, "Opis");
            LandRegistry landRegistry = new LandRegistry(cadastralParticle);

            var person = new PhysicalPerson("12345678901", "Ime", "Prezime") {
                Address = new Address("Ulica", "1", city)
            };

            var partitionSpace = landRegistry.CreatePartitionSpace("123", 12, "Opis etaže", person);

            LegalPerson legalPerson = new LegalPerson("12345678902", "Ime") {
                NumberOfBankAccount = "123456",
                Address = new Address("Ulica", "2", city)
            };
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            Building building = new Building(buildingManager) {
                LandRegistry = landRegistry
            };

            Bill bill = new Bill(legalPerson, building.Reserve, "opis plaćanja", 23) {
                ReferenceNumber = "123"
            };
            bill.AddBillItem(new BillItem(1, 12.3m, "Opis"));

            IBillsRepository billsRepository = new BillsNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var transaction = session.BeginTransaction()) {
                    session.Save(city);
                    session.Save(person);
                    session.Save(legalPerson);
                    session.Save(cadastre);
                    session.Save(landRegistry);
                    session.Save(buildingManager);
                    session.Save(building);

                    billsRepository.SaveOrUpdate(bill);

                    transaction.Commit();
                }
            }

            IList<Bill> billsFromDb = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var transaction = session.BeginTransaction()) {
                    billsFromDb = billsRepository.GetAll().ToList();
                    transaction.Commit();
                }
            }

            // Assert
            Assert.IsTrue(billsFromDb.Count == 1, "No Bill from database.");
        }
        public static BuildingManager getBuildingManager()
        {
            LegalPerson legalPerson = new LegalPerson("12345678902", "Upravitelj") {
                NumberOfBankAccount = "1234567"
            };
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            return buildingManager;
        }
        public void Can_Save_Maintenance_To_DB()
        {
            // Arrange
            var person = new PhysicalPerson("12345678901", "Ime", "Prezime");
            MaintenanceRequest maintenanceRequest = new MaintenanceRequest(
                person
                , "Kvar na grijanju"
                , "Grijanje ne radi"
                , "Prvi kat, stan 2");

            City city = new City(10000, "Zagreb");
            Cadastre cadastre = new Cadastre("Trnje", "12345", city);
            CadastralParticle cadastralParticle = new CadastralParticle(cadastre, "123", 23, "Opis");
            LandRegistry landRegistry = new LandRegistry(cadastralParticle);

            var partitionSpace = landRegistry.CreatePartitionSpace("123", 12, "Opis etaže", person);

            LegalPerson legalPerson = new LegalPerson("12345678902", "Ime");
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            Building building = new Building(buildingManager) {
                LandRegistry = landRegistry
            };

            RepairService repairService = new RepairService("Popravak grijanja");

            Maintenance maintenance = new Maintenance(maintenanceRequest, Urgency.Normal, repairService, building);

            IMaintenancesRepository maintenancesRepository = new MaintenancesNHRepository(SessionFactory);

            // Act
            IList<Maintenance> maintenancesFromDb = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = session.BeginTransaction()) {
                    session.Save(person);
                    session.Save(city);
                    session.Save(legalPerson);
                    session.Save(cadastre);
                    session.Save(landRegistry);
                    session.Save(buildingManager);
                    session.Save(building);
                    session.Save(repairService);

                    maintenancesRepository.SaveOrUpdate(maintenance);

                    tx.Commit();
                }

                using (var tx = session.BeginTransaction()) {
                    maintenancesFromDb = maintenancesRepository.GetAll().ToList();
                    tx.Commit();
                }
            }

            // Assert
            Assert.IsTrue(maintenancesFromDb.Count == 1, "No Maintenance from database.");
        }
        public void Can_Read_Reserve_From_Db()
        {
            // Arrange
            City city = new City(10000, "Zagreb");
            Cadastre cadastre = new Cadastre("Trnje", "12345", city);
            CadastralParticle cadastralParticle = new CadastralParticle(cadastre, "123", 23, "Opis");
            LandRegistry landRegistry = new LandRegistry(cadastralParticle);

            var person = new PhysicalPerson("12345678901", "Ime", "Prezime");
            var partitionSpace = landRegistry.CreatePartitionSpace("123", 12, "Opis etaže", person);

            LegalPerson legalPerson = new LegalPerson("12345678902", "Ime") {
                NumberOfBankAccount = "12332213",
                Address = new Address("dsa", "2", city)
            };
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            Building building = new Building(buildingManager) {
                LandRegistry = landRegistry
            };

            Bill bill = new Bill(legalPerson, building.Reserve, "račun", 23) {
                ReferenceNumber = "123"
            };
            building.Reserve.AddBillForPayment(bill);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var transaction = session.BeginTransaction()) {
                    session.Save(city);
                    session.Save(cadastre);
                    session.Save(person);
                    session.Save(landRegistry);
                    session.Save(legalPerson);
                    session.Save(buildingManager);
                    session.Save(building);

                    transaction.Commit();
                }
            }

            IReservesRepository reservesRepository = new ReservesNHRepository(SessionFactory);
            IList<Reserve> reservesFromDb = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var transaction = session.BeginTransaction()) {
                    reservesFromDb = reservesRepository.GetAll().ToList();
                    transaction.Commit();
                }
            }

            // Assert
            Assert.IsTrue(reservesFromDb.Count == 1, "No Reserves from database.");
            //Assert.IsTrue(reservesFromDb[0].ReserveBills.Count == 1);
        }
        public void Can_Create_MaintenanceRequest()
        {
            // Arrange
            LegalPerson person = new LegalPerson("12345678901", "Mile");

            // Act
            MaintenanceRequest maintenanceRequest = new MaintenanceRequest(person, "Kvar", "Ne radi grijanje.", "Stan Mile, prvi kat.");

            // Assert
            Assert.IsNotNull(maintenanceRequest, "MaintenanceRequest was not created.");
        }
        public void Can_Create_Owned_PartitionSpace()
        {
            // Arrange
            var owner = new LegalPerson("12345678901", "Coca Cola");

            // Act
            var ownedPartitionSpace = landRegistry.CreatePartitionSpace("123", 23, "Dvosoban stan", owner);

            // Assert
            Assert.IsNotNull(ownedPartitionSpace);
        }
        public void Can_Save_AdminJobsVoting_To_DB()
        {
            // Arrange
            City city = new City(10000, "Zagreb");
            Cadastre cadastre = new Cadastre("Trnje", "12345", city);
            CadastralParticle cadastralParticle = new CadastralParticle(cadastre, "123", 23, "Opis");
            LandRegistry landRegistry = new LandRegistry(cadastralParticle);

            var person = new PhysicalPerson("12345678901", "Ime", "Prezime");
            var partitionSpace = landRegistry.CreatePartitionSpace("123", 12, "Opis etaže", person);

            LegalPerson legalPerson = new LegalPerson("12345678902", "Ime");
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            Building building = new Building(buildingManager) {
                LandRegistry = landRegistry
            };

            AdministrationJobsVoting administrationJobsVoting = new AdministrationJobsVoting(
                AdministrationJobsType.Regular,
                building,
                "Subject",
                "Description",
                new DateTime(2011, 11, 11));

            AdminJobsVotingsNHRepository adminJobsVotingsNhRepository = new AdminJobsVotingsNHRepository(SessionFactory);

            // Act
            AdministrationJobsVoting adminJobsVotingFromDb = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = session.BeginTransaction()) {
                    session.Save(city);
                    session.Save(person);
                    session.Save(legalPerson);
                    session.Save(cadastre);
                    session.Save(landRegistry);
                    session.Save(buildingManager);
                    session.Save(building);

                    adminJobsVotingsNhRepository.SaveOrUpdate(administrationJobsVoting);
                    tx.Commit();
                }

                using (var tx = session.BeginTransaction()) {
                    adminJobsVotingFromDb = adminJobsVotingsNhRepository.GetById(administrationJobsVoting.Id);
                    tx.Commit();
                }
            }

            // Assert
            Assert.AreEqual(administrationJobsVoting, adminJobsVotingFromDb, "Two administration jobs voting entities aren't equal.");
        }
        public void Can_Create_BuildingManager()
        {
            // Arrange
            LegalPerson legalPerson = new LegalPerson("12345678901", "Mile d.o.o.");

            // Act
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            // Assert
            Assert.IsNotNull(buildingManager);
            Assert.AreEqual(legalPerson, buildingManager.LegalPerson);
            Assert.IsFalse(buildingManager.Contractors.Any());
        }
        public void Can_Create_Contractor()
        {
            // Arrange
            LegalPerson legalPerson = new LegalPerson("12345678901", "Mile d.o.o.");

            // Act
            Contractor contractor = new Contractor(legalPerson);

            // Assert
            Assert.IsNotNull(contractor);
            Assert.AreEqual(legalPerson, contractor.LegalPerson);
            Assert.IsFalse(contractor.RepairServices.Any());
        }
        public void Date_And_Time_Of_Request_Are_Current_After_Creation()
        {
            // Arrange
            LegalPerson person = new LegalPerson("12345678901", "Mile");
            DateTime theTimeBefore = DateTime.Now.AddMilliseconds(-1);

            // Act
            MaintenanceRequest maintenanceRequest = new MaintenanceRequest(person, "Kvar", "Ne radi grijanje.", "Stan Mile, prvi kat.");

            // Assert
            Assert.IsTrue(maintenanceRequest.DateTimeOfRequest > theTimeBefore);
            Assert.IsTrue(maintenanceRequest.DateTimeOfRequest < DateTime.Now.AddMilliseconds(1));
        }
Example #18
0
        /// <summary>
        /// Konstruktor (izdaje pravna osoba za pričuvu/zgradu)
        /// </summary>
        /// <param name="legalPersonFrom">pravna osoba koja šalje račun za zgradu</param>
        /// <param name="reserve">Pričuva</param>
        /// <param name="paymentDescription">opis plaćanja</param>
        /// <param name="tax">porez/PDV</param>
        public Bill(LegalPerson legalPersonFrom, Reserve reserve, string paymentDescription, short tax)
        {
            if (String.IsNullOrEmpty(legalPersonFrom.NumberOfBankAccount)) {
                throw new BusinessRulesException("Legal Person has not valid bank account number.");
            }

            to = null;
            this.reserve = reserve;
            from = new LegalPersonSnapshot(legalPersonFrom);
            this.paymentDescription = paymentDescription;
            this.tax = tax;
            dateTimeIssued = DateTime.Now;
            isPaid = false;

            billItems = new List<BillItem>();
        }
        public void Can_Delete_User()
        {
            // Arrange
            var password = "******";
            var passwordCoderMock = new Mock<IPasswordCoder>();
            passwordCoderMock.Setup(pc => pc.PasswordFormat).Returns(MembershipPasswordFormat.Clear);
            var encodedPassword = Encoding.Default.GetBytes(password);
            passwordCoderMock.Setup(pc => pc.Encode(encodedPassword))
                                            .Returns(encodedPassword);

            HousingMgmtUser user = new HousingMgmtUser("username", password, passwordCoderMock.Object) {
                Email = "*****@*****.**"
            };

            LegalPerson legalPerson = new LegalPerson("12345678902", "FER");

            user.Person = legalPerson;

            UsersNHRepository usersNHRepository = new UsersNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    usersNHRepository.SaveOrUpdate(user);
                    tx.Commit();
                }
            }

            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    usersNHRepository.Delete(user);
                    tx.Commit();
                }
            }

            HousingMgmtUser fetchedUser = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    fetchedUser = usersNHRepository.GetById(user.Id) as HousingMgmtUser;
                    tx.Commit();
                }

            }

            // Assert
            Assert.IsTrue(fetchedUser == null, "FetchedUser isn't null.");
        }
        public void Can_Take_Snapshot_Of_Person()
        {
            // Arrange
            LegalPerson person = new LegalPerson("12345678901", "Mile");
            Telephone telephone1 = new Telephone("Kucni telefon", "123456");
            Telephone telephone2 = new Telephone("Mobitel", "098123456");

            person.AddTelephone(telephone1);
            person.AddTelephone(telephone2);

            // Act
            var personSnapshot = new PersonSnapshot(person);

            // Assert
            Assert.AreEqual(person.Oib, personSnapshot.Oib);
            Assert.AreEqual(person.Name, personSnapshot.FullName);
            Assert.AreEqual(person.Address, personSnapshot.Address);
        }
        public void Can_Save_Building_To_DB()
        {
            // Arrange
            City city = new City(10000, "Zagreb");
            Cadastre cadastre = new Cadastre("Trnje", "12345", city);
            CadastralParticle cadastralParticle = new CadastralParticle(cadastre, "123", 23, "Opis");
            LandRegistry landRegistry = new LandRegistry(cadastralParticle);

            var person = new PhysicalPerson("12345678901", "Ime", "Prezime");
            var partitionSpace = landRegistry.CreatePartitionSpace("123", 12, "Opis etaže", person);

            LegalPerson legalPerson = new LegalPerson("12345678902", "Ime");
            BuildingManager buildingManager = new BuildingManager(legalPerson);

            Building building = new Building(buildingManager) {
                LandRegistry = landRegistry
            };

            BuildingsNHRepository buildingsNhRepository = new BuildingsNHRepository(SessionFactory);

            // Act
            Building buildingFromDb = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = session.BeginTransaction()) {
                    session.Save(city);
                    session.Save(person);
                    session.Save(legalPerson);
                    session.Save(cadastre);
                    session.Save(landRegistry);
                    session.Save(buildingManager);

                    buildingsNhRepository.SaveOrUpdate(building);
                    tx.Commit();
                }

                using (var tx = session.BeginTransaction()) {
                    buildingFromDb = buildingsNhRepository.GetById(building.Id);
                    tx.Commit();
                }
            }

            // Assert
            Assert.AreEqual(building, buildingFromDb, "Two building entities aren't equal.");
        }
        public void Can_Pay_Bill_From_Reserve()
        {
            // Arrange
            Reserve reserve = building.Reserve;
            decimal currentMoneyStatus = reserve.Money;

            LegalPerson legalPerson = new LegalPerson("12345678901", "Mile d.o.o.") {
                NumberOfBankAccount = "1234"
            };

            Bill bill = new Bill(legalPerson, building.Reserve, "opis plaćanja", 23);
            reserve.AddBillForPayment(bill);

            // Act
            reserve.PayBill(bill);

            // Assert
            Assert.AreEqual(currentMoneyStatus - bill.TotalAmountWithTax, reserve.Money);
            Assert.IsTrue(bill.IsPaid);
        }
        public void Can_Add_Services_To_Contractor()
        {
            // Arrange
            LegalPerson legalPerson = new LegalPerson("12345678901", "Mile d.o.o.");

            RepairService repairService1 = new RepairService("Ličenje");
            RepairService repairService2 = new RepairService("vodovodne cijevi");
            RepairService[] repairServices = new RepairService[] {
                repairService1,
                repairService2
            };

            // Act
            Contractor contractor = new Contractor(legalPerson, repairServices);
            RepairService repairService3 = new RepairService("parketi");
            contractor.AddRepairService(repairService3);

            // Assert
            Assert.AreEqual(3, contractor.RepairServices.Count);
            Assert.AreEqual(repairService1, contractor.RepairServices.ElementAt(0));
            Assert.AreEqual(repairService2, contractor.RepairServices.ElementAt(1));
            Assert.AreEqual(repairService3, contractor.RepairServices.ElementAt(2));
        }
Example #24
0
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="legalPerson">pravna osoba</param>
 /// <param name="repairServices">usluge koje obavlja izovdac radova</param>
 public Contractor(LegalPerson legalPerson, ICollection<RepairService> repairServices)
 {
     this.legalPerson = legalPerson;
     this.repairServices = new HashedSet<RepairService>(repairServices);
 }
Example #25
0
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="legalPerson">pravna osoba</param>
 public Contractor(LegalPerson legalPerson)
     : this(legalPerson, new HashedSet<RepairService>())
 {
 }
        public void Can_Save_Person_To_DB()
        {
            // Arrange
            var password = "******";
            var passwordCoderMock = new Mock<IPasswordCoder>();
            passwordCoderMock.Setup(pc => pc.PasswordFormat).Returns(MembershipPasswordFormat.Clear);
            var encodedPassword = Encoding.Default.GetBytes(password);
            passwordCoderMock.Setup(pc => pc.Encode(encodedPassword))
                                          	.Returns(encodedPassword);

            HousingMgmtUser user = new HousingMgmtUser("username", password, passwordCoderMock.Object) {
                Email = "*****@*****.**"
            };

            LegalPerson legalPerson = new LegalPerson("12345678902", "FER");

            user.Person = legalPerson;

            UsersNHRepository usersNHRepository = new UsersNHRepository(SessionFactory);

            // Act
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    usersNHRepository.SaveOrUpdate(user);
                    tx.Commit();
                }
            }

            HousingMgmtUser fetchedUser = null;
            using (var session = SessionFactory.OpenSession()) {
                using (var tx = Session.BeginTransaction()) {
                    fetchedUser = usersNHRepository.GetById(user.Id) as HousingMgmtUser;
                    tx.Commit();
                }

            }

            // Assert
            Assert.IsTrue(fetchedUser != null, "FetchedUser is null.");
            Assert.AreEqual(legalPerson, fetchedUser.Person, "Persons aren't equal.");
            Assert.AreEqual(DateTime.MinValue.ToLocalTime(), fetchedUser.LastLockoutDate, "Date and Time aren't equal.");
        }
 public void If_Oib_Is_Invalid_Should_Throw_RuleException()
 {
     var person1 = new LegalPerson("123456", "Mile");
     var person2 = new LegalPerson("abs", "Mile");
 }
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="legalPerson">pravna osoba</param>
 /// <param name="contractors">izvodaci radova</param>
 public BuildingManager(LegalPerson legalPerson, ICollection<Contractor> contractors)
 {
     this.legalPerson = legalPerson;
     this.contractors = new HashedSet<Contractor>(contractors);
 }
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="legalPerson">pravna osoba</param>
 public BuildingManager(LegalPerson legalPerson)
     : this(legalPerson, new HashedSet<Contractor>())
 {
 }
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="legalPerson">pravna osoba</param>
 public LegalPersonSnapshot(LegalPerson legalPerson)
     : base(legalPerson)
 {
     this.numberOfBankAccount = legalPerson.NumberOfBankAccount;
 }