/// <summary>
/// Attempts to update a RealEstateCompany instance in the Collection. Returns 1 if succeeds, 0 if fails.
/// </summary>
/// <param name="realEstateCompany"></param>
/// <returns></returns>
public int Update(RealEstateCompany realEstateCompany)
{
if (realEstateCompany != null)
{
int realEstateCompanyIDX = _recoList.FindIndex(r => r.CompanyID == realEstateCompany.CompanyID);
RealEstateCompany collectionRECo = null;
if (realEstateCompanyIDX > -1)
{
collectionRECo = _recoList[realEstateCompanyIDX];
}
if (collectionRECo != null)
{
if (LogicBroker.UpdateExistingItem <RealEstateCompany>(realEstateCompany))
{
RealEstateCompany storedRECo = LogicBroker.GetReCompany(realEstateCompany.CompanyID);
if (storedRECo != null)
{
this._recoList[realEstateCompanyIDX] = storedRECo;
collectionMonitor.SendNotifications(1, "RECo");
return(1);
}
}
}
else
{
return(this.Add(realEstateCompany));
}
}
return(0);
}
/// <summary>
/// Add a HomeSale instance to this collection. Will only accept object whose MarketDate and SaleAmount members are not null
/// and the homesale instance is not already in the collection.
/// </summary>
/// <param name="homeSale"></param>
public int Add(HomeSale homeSale)
{
if (homeSale != null)
{
int preCount = this.Count;
HomeSale collectionHomeSale = _homeSalesList.SingleOrDefault(hs => hs.MarketDate == homeSale.MarketDate &&
hs.SaleAmount == homeSale.SaleAmount);
if (collectionHomeSale == null)
{
if (LogicBroker.StoreItem <HomeSale>(homeSale))
{
HomeSale storedHomeSale = LogicBroker.GetHomeSale(homeSale.SaleID);
if (storedHomeSale != null)
{
_homeSalesList.Add(storedHomeSale);
if (this.Count > preCount)
{
collectionMonitor.SendNotifications(1, "HomeSale");
return(1);
}
}
}
}
}
return(0);
}
/// <summary>
/// Allows caller to add a Person to the Collection based on PersonID
/// </summary>
/// <param name="person"></param>
public int Add(T person)
{
if (person != null)
{
int preCount = this.Count;
Person collectionPerson = _peopleList.SingleOrDefault(p =>
p.FirstName == person.FirstName && p.LastName == person.LastName);
if (collectionPerson == null)
{
if (LogicBroker.StoreItem <Person>(person))
{
Person storedPerson = LogicBroker.GetPerson(person.PersonID);
if (storedPerson != null)
{
_peopleList.Add((T)storedPerson);
if (this.Count > preCount)
{
collectionMonitor.SendNotifications(1, "Person");
return(1);
}
}
}
}
}
return(0);
}
/// <summary>
/// Updates an existing home instance in database and Collection using Home arg. Returns 1 if change(s) applied, 0 if no changes made.
/// </summary>
/// <param name="home"></param>
/// <returns name="int"></returns>
public int Update(Home home)
{
if (home != null)
{
int homeIDX = _homesList.FindIndex(h => h.HomeID == home.HomeID);
Home collectionHome = null;
if (homeIDX > -1)
{
collectionHome = _homesList[homeIDX];
}
if (collectionHome != null)
{
if (LogicBroker.UpdateExistingItem <Home>(home))
{
Home storedHome = LogicBroker.GetHome(home.HomeID);
if (storedHome != null)
{
this._homesList[homeIDX] = storedHome;
collectionMonitor.SendNotifications(1, "Home");
return(1);
}
}
}
else
{
return(this.Add(home));
}
}
return(0);
}
/// <summary>
/// Attempts to add a RealEstateCompany instance to the Collection and the Database. Returns True if succeeds, False if otherwise.
/// </summary>
/// <param name="realEstateCompany"></param>
/// <returns></returns>
public int Add(RealEstateCompany realEstateCompany)
{
if (realEstateCompany != null)
{
int preCount = this.Count;
RealEstateCompany collectionReco = _recoList
.SingleOrDefault(re =>
re.CompanyName == realEstateCompany.CompanyName);
if (collectionReco == null)
{
if (LogicBroker.StoreItem <RealEstateCompany>(realEstateCompany))
{
RealEstateCompany storedReco = LogicBroker.GetReCompany(realEstateCompany.CompanyID);
if (storedReco != null)
{
this._recoList.Add(storedReco);
if (this.Count > preCount)
{
collectionMonitor.SendNotifications(1, "RECo");
return(1);
}
}
}
}
}
return(0);
}
/// <summary>
/// Adds an instance to this item list.
/// </summary>
/// <param name="home"></param>
public int Add(Home home)
{
if (home != null)
{
int preCount = this.Count;
Home collectionHome = _homesList.SingleOrDefault(h => h.Address == home.Address &&
h.Zip == home.Zip);
if (collectionHome == null)
{
if (LogicBroker.StoreItem <Home>(home))
{
Home storedHome = LogicBroker.GetHome(home.HomeID);
if (storedHome != null)
{
this._homesList.Add(storedHome);
if (this.Count > preCount)
{
collectionMonitor.SendNotifications(1, "Home");
return(1);
}
}
}
}
}
return(0);
}
/// <summary>
/// Takes a Person, Agent, Buyer, or Owner instance and attempts to remove it from the Collection and the Database. Returns True if succeeds, False if otherwise.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool Remove(T item)
{
bool result = false;
if (item != null)
{
if (item.GetType().Name == "Agent")
{
var agent = item as Agent;
result = this.RemoveAgent(agent);
}
if (item.GetType().Name == "Buyer")
{
var buyer = item as Buyer;
result = this.RemoveBuyer(buyer);
}
if (item.GetType().Name == "Owner")
{
var owner = item as Owner;
result = this.RemoveOwner(owner);
}
if (item.GetType().Name == "Person")
{
Person person = item as Person;
if (_peopleList.Contains(person))
{
var personIDX = _peopleList.FindIndex(p => p.PersonID == person.PersonID);
if (person.Agent != null)
{
this.RemoveAgent(person.Agent);
}
if (person.Buyer != null)
{
this.RemoveBuyer(person.Buyer);
}
if (person.Owner != null)
{
this.RemoveOwner(person.Owner);
}
if (LogicBroker.RemoveEntity <Person>(person))
{
collectionMonitor.SendNotifications(1, "Person");
_peopleList.RemoveAt(personIDX);
return(true);
}
}
}
}
return(result);
}
private void Application_Exit(object sender, ExitEventArgs e)
{
if (LogicBroker.BackUpDatabase())
{
HSTLogger.Data("App Exit", "Backup of files complete.");
}
else
{
HSTLogger.Data("App Exit", "Unable to backup to file system.");
MessageBox.Show("Backup failed.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
HSTLogger.Flush();
}
public void InitDatabaseTest()
{
var result = false;
if (LogicBroker.InitDatabase())
{
Console.WriteLine("Database initialization completed successfully");
result = true;
}
else
{
Console.WriteLine("Database initialization failed.");
}
Assert.IsTrue(result);
}
public void LoadDatabaseDataTest()
{
var result = false;
if (LogicBroker.LoadData())
{
Console.WriteLine("Database data loaded successfully.");
result = true;
}
else
{
Console.WriteLine("Database data load failed.");
}
Assert.IsTrue(result);
}
/// <summary>
/// Attempts to update Person information (Phone or EMail) in the DB and Collection. Agent, Buyer, or Owner are delegated. Returns zero if no changes were made.
/// </summary>
/// <param name="person"></param>
/// <returns></returns>
public int UpdatePerson(T person)
{
if (person == null)
{
return(0);
}
int result = 0;
int personIDX = _peopleList.FindIndex(p => p.PersonID == person.PersonID);
Person collectionPerson = null;
if (personIDX > -1)
{
collectionPerson = _peopleList[personIDX];
}
if (collectionPerson != null)
{
if (LogicBroker.UpdateExistingItem <Person>(person))
{
Person storedPerson = LogicBroker.GetPerson(person.PersonID);
if (storedPerson != null)
{
this[personIDX] = (T)storedPerson;
result = 1;
}
}
}
if (collectionPerson == null)
{
result = this.Add(person);
}
result += UpdateAgent(person.Agent);
result += UpdateBuyer(person.Buyer);
result += UpdateOwner(person.Owner);
if (result > 0)
{
collectionMonitor.SendNotifications(1, "Person");
}
return(result);
}
private void Application_Startup(object sender, StartupEventArgs e)
{
// portions of code are thanks to a Gist by Ronnie Overby at https://gist.github.com/ronnieoverby/7568387
HSTLogger = new Logger();
if (HSTLogger.IsEnabled)
{
AppDomain.CurrentDomain.UnhandledException += (sig, exc) =>
LogUnhandledException((Exception)exc.ExceptionObject, "AppDomain.CurrentDomain.UnhandledException");
DispatcherUnhandledException += (sig, exc) =>
LogUnhandledException(exc.Exception, "Application.Current.DispatcherUnhandledException");
TaskScheduler.UnobservedTaskException += (sig, exc) =>
LogUnhandledException(exc.Exception, "TaskScheduler.UnobservedTaskException");
HSTLogger.Data("Application Startup", "Initialize Database called");
try
{
if (DatabaseInitLoaded = LogicBroker.InitDatabase())
{
HSTLogger.Data("Application Startup", "Initialize Database completed. Launching UI.");
DoDbBackup = true;
_peopleCollection = Factory.CollectionFactory.GetPeopleCollectionObject();
_homesCollection = Factory.CollectionFactory.GetHomesCollectionObject();
_homeSalesCollection = Factory.CollectionFactory.GetHomeSalesCollectionObject();
_recosCollection = Factory.CollectionFactory.GetRECosCollectionObject();
new MainWindow().Show();
}
else
{
HSTLogger.Data("Application Startup", "Application Startup failed to load file data.");
}
HSTLogger.Flush();
}
catch (Exception ex)
{
HSTLogger.Data("WindowLoading Exception thrown", ex.Message);
LogInnerExceptionMessages(ex, "WindowLoading InnerException");
HSTLogger.Flush();
_ = MessageBox.Show($"While launching, the application was unable to load the backup files. Application will now close.", "Unable to load file data.", MessageBoxButton.OK);
DoDbBackup = false;
App.Current.Shutdown();
}
}
}
/// <summary>
/// Attempts to remove a RealEstateCompany instance from the Collection and the Database. Returns True if succeeds, False if otherwise.
/// </summary>
/// <param name="realEstateCompany"></param>
/// <returns></returns>
public bool Remove(RealEstateCompany realEstateCompany)
{
if (realEstateCompany != null)
{
if (_recoList.Contains(realEstateCompany))
{
if (LogicBroker.RemoveEntity <RealEstateCompany>(realEstateCompany))
{
if (_recoList.Remove(realEstateCompany))
{
collectionMonitor.SendNotifications(1, "RECo");
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Accepts a Home instance and attempts to remove from the Database and the Collection. Returns True if succeeds, False if no changes made.
/// </summary>
/// <param name="home"></param>
/// <returns></returns>
public bool Remove(Home home)
{
if (home != null)
{
if (_homesList.Contains(home))
{
if (LogicBroker.RemoveEntity <Home>(home))
{
if (_homesList.Remove(home))
{
collectionMonitor.SendNotifications(1, "Home");
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Attempts to update the Buyer Object in the database and updates the Person instance in the Collection with the updated Buyer info.
/// </summary>
/// <param name="buyer"></param>
/// <returns></returns>
internal int UpdateBuyer(Buyer buyer)
{
if (buyer == null || buyer.BuyerID < 0)
{
return(0);
}
Buyer dbBuyer = null;
int personIDX = _peopleList.FindIndex(p => p.PersonID == buyer.BuyerID);
Person collectionPerson = _peopleList[personIDX];
if (collectionPerson.Buyer == buyer)
{
return(0);
}
int result = 0;
bool buyerStored = false;
dbBuyer = LogicBroker.GetBuyer(collectionPerson.PersonID);
if (dbBuyer == null)
{
buyerStored = LogicBroker.StoreItem <Buyer>(buyer);
}
else
{
buyerStored = LogicBroker.UpdateExistingItem <Buyer>(buyer);
}
if (buyerStored)
{
dbBuyer = LogicBroker.GetBuyer(collectionPerson.PersonID);
this[personIDX].Buyer = dbBuyer;
result = 1;
collectionMonitor.SendNotifications(1, "Person");
collectionMonitor.SendNotifications(1, "Buyer");
}
return(result);
}
/// <summary>
/// Attempts to update the Agent Object in the database and updates the Person instance in the Collection with the updated Agent info.
/// </summary>
/// <param name="agent"></param>
/// <returns></returns>
internal int UpdateAgent(Agent agent)
{
if (agent == null || agent.AgentID < 0)
{
return(0);
}
Agent dbAgent = null;
int personIDX = _peopleList.FindIndex(p => p.PersonID == agent.AgentID);
Person collectionPerson = _peopleList[personIDX];
if (collectionPerson.Agent == agent)
{
return(0);
}
int result = 0;
bool agentStored = false;
dbAgent = LogicBroker.GetAgent(collectionPerson.PersonID);
if (dbAgent == null)
{
agentStored = LogicBroker.StoreItem <Agent>(agent);
}
else
{
agentStored = LogicBroker.UpdateExistingItem <Agent>(agent);
}
if (agentStored)
{
dbAgent = LogicBroker.GetAgent(collectionPerson.PersonID);
this[personIDX].Agent = dbAgent;
result = 1;
collectionMonitor.SendNotifications(1, "Person");
collectionMonitor.SendNotifications(1, "Agent");
}
return(result);
}
/// <summary>
/// Attempts to update the Owner Object in the database and updates the Person instance in the Collection with the updated Owner info.
/// </summary>
/// <param name="owner"></param>
/// <returns></returns>
internal int UpdateOwner(Owner owner)
{
if (owner == null || owner.OwnerID < 0)
{
return(0);
}
Owner dbOwner = null;
int personIDX = _peopleList.FindIndex(p => p.PersonID == owner.OwnerID);
Person collectionPerson = _peopleList[personIDX];
int result = 0;
bool ownerStored = false;
dbOwner = LogicBroker.GetOwner(collectionPerson.PersonID);
if (dbOwner == null)
{
ownerStored = LogicBroker.StoreItem <Owner>(owner);
}
else
{
ownerStored = LogicBroker.UpdateExistingItem <Owner>(owner);
}
if (ownerStored)
{
dbOwner = LogicBroker.GetOwner(collectionPerson.PersonID);
this[personIDX].Owner = dbOwner;
result = 1;
collectionMonitor.SendNotifications(1, "Person");
collectionMonitor.SendNotifications(1, "Owner");
}
return(result);
}
/// <summary>
/// Private helper method removes Agent instance from the DB.
/// </summary>
/// <param name="agent"></param>
/// <returns></returns>
private bool RemoveAgent(Agent agent)
{
return(LogicBroker.RemoveEntity <Agent>(agent));
}
public void OneBigTest()
{
{
#region LogicBrokerTests
// GetPerson(PersonID)
{
var expectedPerson = new Person()
{
FirstName = "John",
LastName = "Smith",
Email = "*****@*****.**",
Phone = "1112223333"
};
int personID = 1;
Person actualPerson = LogicBroker.GetPerson(personID);
bool areEqual = expectedPerson.Equals(actualPerson);
Assert.IsTrue(areEqual);
}
// GetPerson(firstname, lastname)
{
string firstName = "John";
string lastName = "Smith";
var expectedPerson = new Person()
{
FirstName = firstName,
LastName = lastName,
Email = "*****@*****.**",
Phone = "1112223333"
};
Person actualPerson = LogicBroker.GetPerson(firstName, lastName);
bool areEqual = expectedPerson.Equals(actualPerson);
Assert.IsTrue(areEqual);
}
// GetHome(homeID)
{
var address = "23 Oak St.";
var zip = "955551111";
var expectedHome = new Home()
{
Address = address,
City = "Johnsonville",
State = "CA",
Zip = zip
};
int homeID = 1;
Home actualHome = LogicBroker.GetHome(homeID);
bool areEqual = expectedHome.Equals(actualHome);
Assert.IsTrue(areEqual);
}
// GetHome(address, zip)
{
var address = "23 Oak St.";
var zip = "955551111";
var expectedHome = new Home()
{
Address = address,
City = "Johnsonville",
State = "CA",
Zip = zip
};
Home actualHome = LogicBroker.GetHome(address, zip);
bool areEqual = expectedHome.Equals(actualHome);
Assert.IsTrue(areEqual);
}
// GetHomeSale(saleID)
// SOLD
{
int homesaleID = 6;
var expectedHomeSale = new HomeSale()
{
SaleID = homesaleID,
HomeID = 3,
SoldDate = new DateTime(2014, 06, 13),
AgentID = 1,
SaleAmount = 550_000m,
BuyerID = 5,
MarketDate = new DateTime(2014, 06, 01),
CompanyID = 4
};
var actualHomeSale = LogicBroker.GetHomeSale(homesaleID);
bool areEqual = expectedHomeSale.Equals(actualHomeSale);
if (!areEqual)
{
var items = new List <HomeSale>()
{
expectedHomeSale, actualHomeSale
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetHomeSale(marketDate, saleAmount)
// SOLD
{
int homesaleID = 6;
var marketDate = new DateTime(2015, 03, 01);
var saleAmount = 335_000m;
var expectedHomeSale = new HomeSale()
{
SaleID = homesaleID,
HomeID = 1,
SoldDate = new DateTime(2010, 03, 15),
AgentID = 1,
SaleAmount = saleAmount,
BuyerID = 1,
MarketDate = marketDate,
CompanyID = 2
};
var actualHomeSale = LogicBroker.GetHomeSale(marketDate, saleAmount);
bool areEqual = expectedHomeSale.Equals(actualHomeSale);
if (!areEqual)
{
var items = new List <HomeSale>()
{
expectedHomeSale, actualHomeSale
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetHomeSale(saleID)
// FOR SALE
{
var saleID = 1;
var expectedHomeForSale = new HomeSale()
{
SaleID = saleID,
HomeID = 3,
SoldDate = null,
AgentID = 4,
SaleAmount = 700_000m,
MarketDate = new DateTime(2016, 08, 15),
CompanyID = 1
};
var actualHomeForSale = LogicBroker.GetHomeSale(saleID);
bool areEqual = expectedHomeForSale.Equals(actualHomeForSale);
if (!areEqual)
{
var items = new List <HomeSale>()
{
expectedHomeForSale, actualHomeForSale
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetReCompany(companyID)
{
int companyID = 3;
var expectedRECo = new RealEstateCompany()
{
CompanyID = companyID,
CompanyName = "Rapid Real Estate",
Phone = "6662221111"
};
var actualRECo = LogicBroker.GetReCompany(companyID);
bool areEqual = expectedRECo.Equals(actualRECo);
if (!areEqual)
{
var items = new List <RealEstateCompany>()
{
expectedRECo, actualRECo
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetReCompany(companyName)
{
int companyID = 3;
var companyName = "Rapid Real Estate";
var expectedRECo = new RealEstateCompany()
{
CompanyID = companyID,
CompanyName = companyName,
Phone = "6662221111"
};
var actualRECo = LogicBroker.GetReCompany(companyName);
bool areEqual = expectedRECo.Equals(actualRECo);
if (!areEqual)
{
var items = new List <RealEstateCompany>()
{
expectedRECo, actualRECo
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetAgent(AgentID)
{
var agentID = 4;
var expectedAgent = new Agent()
{
AgentID = agentID,
CompanyID = 1,
CommissionPercent = 0.03m
};
var actualAgent = LogicBroker.GetAgent(agentID);
bool areEqual = expectedAgent.Equals(actualAgent);
if (!areEqual)
{
var items = new List <Agent>()
{
expectedAgent, actualAgent
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetBuyer(BuyerID)
{
var buyerID = 7;
var expectedBuyer = new Buyer()
{
BuyerID = buyerID,
CreditRating = 780
};
var actualBuyer = LogicBroker.GetBuyer(buyerID);
bool areEqual = expectedBuyer.Equals(actualBuyer);
if (!areEqual)
{
var items = new List <Buyer>()
{
expectedBuyer, actualBuyer
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// GetOwner(OwnerID)
{
var ownerID = 7;
var expectedOwner = new Owner()
{
OwnerID = ownerID,
PreferredLender = "Unique Mortgaging"
};
var actualOwner = LogicBroker.GetOwner(ownerID);
bool areEqual = expectedOwner.Equals(actualOwner);
if (!areEqual)
{
var items = new List <Owner>()
{
expectedOwner, actualOwner
};
PrintObjects(items);
}
Assert.IsTrue(areEqual);
}
// UpdateExistingItem<Person>(person)
{
var updatePersonFirstName = "p1FirstName";
var updatePersonLastName = "p2LastName";
var addUpdateRemovePerson = new Person
{
FirstName = updatePersonFirstName,
LastName = updatePersonLastName,
Phone = "123456789",
Email = "*****@*****.**"
};
var expectedStoreResult = true;
var actualStoreResult = LogicBroker.StoreItem <Person>(addUpdateRemovePerson);
PrintObject <Person>(addUpdateRemovePerson, "Update Existing Item addUpdateRemovePerson.");
PrintObject <bool>(actualStoreResult, "Return value from StoreItem().");
if (!actualStoreResult)
{
Console.WriteLine(addUpdateRemovePerson.ToString());
}
Assert.AreEqual(expectedStoreResult, actualStoreResult);
var personToUpdate = LogicBroker.GetPerson(updatePersonFirstName, updatePersonLastName);
PrintObject <Person>(personToUpdate, "Returned Person from GetPerson(firstname, lastname).");
var expectedUpdateResult = true;
var updatePerson = new Person()
{
PersonID = personToUpdate.PersonID,
FirstName = personToUpdate.FirstName,
LastName = personToUpdate.LastName,
Phone = "0000000000",
Email = "*****@*****.**"
};
var actualUpdateResult = LogicBroker.UpdateExistingItem <Person>(updatePerson);
PrintObject <bool>(actualUpdateResult, "Return value from UpdateExistingItem().");
if (actualUpdateResult)
{
Person resultPerson = LogicBroker.GetPerson(addUpdateRemovePerson.FirstName, addUpdateRemovePerson.LastName);
Console.WriteLine(resultPerson.ToString());
}
Assert.AreEqual(expectedUpdateResult, actualUpdateResult);
var expectedRemoveResult = true;
var actualRemoveResult = LogicBroker.RemoveEntity <Person>(updatePerson);
PrintObject <bool>(actualRemoveResult, "Return value from RemoveEntity<Person>().");
if (!actualRemoveResult)
{
Console.WriteLine("RemoveEntity<Person>(addUpdateRemovePerson) failed.");
Console.WriteLine(addUpdateRemovePerson.ToString());
}
Assert.AreEqual(expectedRemoveResult, actualRemoveResult);
}
}
#endregion LogicBrokerTests
#region InitializeCollections
DbPeopleCollection = new PeopleCollection <Person>(EntityLists.GetListOfPeople());
Assert.IsTrue(DbPeopleCollection.Count == 10);
DbHomesCollection = new HomesCollection(EntityLists.GetTreeListOfHomes());
Assert.IsTrue(DbHomesCollection.Count == 5);
DbHomesalesCollection = new HomeSalesCollection(EntityLists.GetListOfHomeSales());
Assert.IsTrue(DbHomesalesCollection.Count == 8);
DbRECosCollection = new RealEstateCosCollection(EntityLists.GetTreeListOfRECompanies());
Assert.IsTrue(DbRECosCollection.Count == 4);
#endregion InitializeCollections
#region PeopleCollectionTests
{
// COUNT
var expectedCount = 10;
var actualCount = DbPeopleCollection.Count;
Assert.AreEqual(expectedCount, actualCount);
// ADD
var personPerson = new Person()
{
FirstName = "Owen",
LastName = "Owner",
Phone = "123456789",
Email = "*****@*****.**"
};
var personAddedCount = DbPeopleCollection.Add(personPerson);
PrintObject <Person>(personPerson, $"Attempted to add Person to PersonCollection. Result: { personAddedCount }.");
Assert.IsTrue(personAddedCount == 1); // Add plain Person
// GET (PersonID by F+L Names)
int addedPersonID = 0;
addedPersonID = DbPeopleCollection.GetPersonIDbyName(personPerson.FirstName, personPerson.LastName);
PrintObject <int>(addedPersonID, "Returned PersonID from GetPersonIDbyName(Owen, Owner).");
Assert.IsTrue(addedPersonID > 10);
// GET (Person by Person)
Person addedPerson = null;
addedPerson = DbPeopleCollection.Get(addedPersonID);
PrintObject <Person>(addedPerson, "Returned Person from Get(addedPersonID).");
Assert.IsTrue(addedPerson != null);
// UPDATE (Person's Phone)
addedPerson.Phone = "3254678451";
var addedPersonUpdated = DbPeopleCollection.UpdatePerson(addedPerson);
PrintObject <Person>(addedPerson, $"UpdatePerson(addedPerson) result: { addedPersonUpdated }.");
Assert.IsTrue(addedPersonUpdated == 1);
// UPDATE (Person as an Owner)
var existingUpdatePerson = DbPeopleCollection.Get(addedPersonID);
var owner = new Owner()
{
OwnerID = addedPerson.PersonID,
PreferredLender = "Lender Test"
};
existingUpdatePerson.Owner = owner;
var ownerPersonUpdated = DbPeopleCollection.UpdatePerson(existingUpdatePerson);
PrintObject <Person>(existingUpdatePerson, $"UpdatePerson(addedPerson) with Owner result: { ownerPersonUpdated }.");
Assert.IsTrue(ownerPersonUpdated > 0);
// REMOVE
var updatePersonWithOwner = DbPeopleCollection.Get(addedPersonID);
var personRemoved = DbPeopleCollection.Remove(updatePersonWithOwner);
PrintObject <Person>(updatePersonWithOwner, $"Removing person from collection result: { personRemoved }.");
Assert.IsTrue(personRemoved); // Remove Person with Owner FK
// CLEAR
DbPeopleCollection.Clear();
expectedCount = 0;
actualCount = DbPeopleCollection.Count;
// REINIT
DbPeopleCollection = new PeopleCollection <Person>(EntityLists.GetListOfPeople());
Assert.IsTrue(DbPeopleCollection.Count == 10);
}
#endregion
#region HomesCollectionTests
{
var newHome = new Home()
{
Address = "4412 153rd Ave SE",
City = "Bellevue",
State = "WA",
Zip = "980060000"
};
// GET HOME BY ADDRESS AND ZIP
// var homeByAddress = DbHomesCollection.GetHome(anAddress, aZipCode);
// GET HOME BY ID
var homeID = 1;
var homeByID = DbHomesCollection.Retreive(homeID);
var expectedHome = new Home()
{
HomeID = 1,
Address = "23 Oak St.",
City = "Johnsonville",
State = "CA",
Zip = "955551111",
OwnerID = 1
};
var expectedResult = true;
var actualResult = expectedHome.Equals(homeByID);
PrintObject <Home>(homeByID, "Get Home by ID Result.");
PrintObject <bool>(actualResult, "Get Home by id actual result:");
Assert.AreEqual(expectedResult, actualResult);
// UPDATE HOME
newHome.OwnerID = 3;
var actualUpdateResult = DbHomesCollection.Update(newHome);
var expectedUpdateResult = 1;
PrintObject <int>(actualUpdateResult, "Update Home actual update result:");
Assert.AreEqual(expectedUpdateResult, actualUpdateResult);
// REMOVE HOME
var expectedRemoveResult = true;
var actualRemoveResult = DbHomesCollection.Remove(newHome.HomeID);
PrintObject <bool>(actualRemoveResult, "Remove Home actual result:");
Assert.AreEqual(expectedRemoveResult, actualRemoveResult);
// CLEAR
//DbHomesCollection.Clear();
//expectedCount = 0;
//actualCount = DbHomesCollection.Count;
//Assert.AreEqual(expectedCount, actualCount);
// REINIT
DbHomesCollection = new HomesCollection(EntityLists.GetTreeListOfHomes());
var expectedCount = 5;
var actualCount = DbHomesCollection.Count;
PrintObject <int>(actualCount, "Actual Count of reinitialized Homes collection.");
Assert.AreEqual(expectedCount, actualCount);
}
#endregion
#region HomeSalesCollectionTests
{
// GET BY ID
var existingSaleID = 1;
var getHomesale = DbHomesalesCollection.Retreive(existingSaleID);
PrintObject <HomeSale>(getHomesale, "Retreived Homesale with SaleID=1: ");
var marketDate = new DateTime(2016, 08, 15);
var expectedHomesale = new HomeSale()
{
SaleID = 6,
HomeID = 3,
AgentID = 4,
SaleAmount = 700000m,
MarketDate = new DateTime(2016, 08, 15),
CompanyID = 1
};
var expectedResult = true;
var actualResult = expectedHomesale.Equals(getHomesale);
Assert.AreEqual(expectedResult, actualResult);
// GET BY ITEM?
// TODO: Implement if necessary
// UPDATE E.G. SELLHOME
var preNewHomesale = DbHomesalesCollection.Retreive(1); // so it can be put back into DB at end of tests
PrintObject <HomeSale>(preNewHomesale, "PreNewHomesale instance, SaleID=1: ");
var newHomeSale = new HomeSale()
{
SaleID = 1,
HomeID = 3,
AgentID = 4,
SaleAmount = 766666m,
MarketDate = new DateTime(2016, 08, 15),
CompanyID = 1,
SoldDate = new DateTime(2020, 08, 15),
BuyerID = 1
};
var actualUpdateResult = DbHomesalesCollection.Update(newHomeSale);
PrintObject <HomeSale>(newHomeSale, "NewHomeSale instance sent to Update method: ");
PrintObject <int>(actualUpdateResult, "UPDATE Home as sold result: ");
var expectedUpdateResult = 1;
Assert.AreEqual(expectedUpdateResult, actualUpdateResult);
// REMOVE
var actualRemoveResult = DbHomesalesCollection.Remove(newHomeSale);
PrintObject <HomeSale>(newHomeSale, "Item sent to Remove() method: ");
var expectedRemoveResult = true;
Assert.AreEqual(expectedRemoveResult, actualRemoveResult);
// GET UPDATE REMOVEFROMMARKET (put homesale back, then remove from market)
var expectedPostRemoveFromMarketCount = DbHomesalesCollection.Count;
var resetHomesale = new HomeSale()
{
SaleID = 6,
HomeID = 3,
AgentID = 4,
SaleAmount = 700000m,
MarketDate = new DateTime(2016, 08, 15),
CompanyID = 1
};
var reAddHomeForSaleToCollectionResult = DbHomesalesCollection.Add(resetHomesale);
PrintObject <HomeSale>(resetHomesale, "ResetHomesale, SaleID=6, sent to Add method: ");
var expectedReAddHomeForSaleToCollectionResult = 1;
Assert.AreEqual(expectedReAddHomeForSaleToCollectionResult, reAddHomeForSaleToCollectionResult);
var expectedPostRemoveFromMarketResult = true;
var actualPostRemoveFromMarketResult = DbHomesalesCollection.Remove(resetHomesale);
PrintObject <HomeSale>(resetHomesale, "ResetHomesale, SaleID=6, sent to Remove method: ");
var actualPostRemoveFromMarketCount = DbHomesalesCollection.Count;
Assert.AreEqual(expectedPostRemoveFromMarketResult, actualPostRemoveFromMarketResult);
Assert.AreEqual(expectedPostRemoveFromMarketCount, actualPostRemoveFromMarketCount);
// CLEAR
// TODO: Implement Clear method if necessary.
}
#endregion
#region RealEstateCompaniesTests
{
// RETREIVE
var recoToRetreiveID = 3;
var retreivedRECo = DbRECosCollection.Retrieve(recoToRetreiveID);
var expectedRECo = new RealEstateCompany()
{
CompanyID = 3,
CompanyName = "Rapid Real Estate",
Phone = "6662221111",
};
var expectedAgentsCount = 1;
var expectedHomesalesCount = 2;
PrintObject <RealEstateCompany>(retreivedRECo, "Expecting Rapid Real Estate. RECo retreived from Collection: ");
var actualRetreivedRECoAgentsCount = retreivedRECo.Agents.Count;
var actualRetreivedRECoHomesalesCount = retreivedRECo.HomeSales.Count;
PrintObject <int>(actualRetreivedRECoAgentsCount, "Expected: 1; Actual AGENTS in retreived RECo instance: ");
PrintObject <int>(actualRetreivedRECoHomesalesCount, "Expected: 2; Actual HOMESALES in retreived RECo instance: ");
Assert.AreEqual(expectedAgentsCount, retreivedRECo.Agents.Count);
Assert.AreEqual(expectedHomesalesCount, retreivedRECo.HomeSales.Count);
var expectedRECoRetreiveResult = true;
var actualRECoRetreiveResult = expectedRECo.Equals(retreivedRECo);
PrintObject <bool>(actualRECoRetreiveResult, "Expected .Equals(): True; Actual comparison result: ");
Assert.AreEqual(expectedRECoRetreiveResult, actualRECoRetreiveResult);
// ADD
var expectedPreCount = DbRECosCollection.Count;
var recoToAdd = new RealEstateCompany()
{
CompanyName = "TestCompany",
Phone = "2061234567"
};
var expectedAddResult = 1;
var actualAddResult = DbRECosCollection.Add(recoToAdd);
Assert.AreEqual(expectedAddResult, actualAddResult);
// SEARCH and store
var recoToRemove = DbRECosCollection.Where(re => re.CompanyName == recoToAdd.CompanyName).FirstOrDefault();
if (recoToRemove == null)
{
Assert.Fail($"Unable to recover added RECo: { recoToAdd }");
}
// Remove
var expectedRemoveResult = true;
var recoRemovalPreCount = DbRECosCollection.Count;
var expectedPostCount = recoRemovalPreCount - 1;
var actualRemoveResult = DbRECosCollection.Remove(recoToRemove.CompanyID); // this exercizes BOTH remove methods
var actualPostCount = DbRECosCollection.Count;
Assert.AreEqual(expectedPostCount, actualPostCount);
Assert.AreEqual(expectedRemoveResult, actualRemoveResult);
}
#endregion
}
}
}
/// <summary>
/// Private helper method removes Buyer instance from the DB.
/// </summary>
/// <param name="buyer"></param>
/// <returns></returns>
private bool RemoveBuyer(Buyer buyer)
{
return(LogicBroker.RemoveEntity <Buyer>(buyer));
}
/// <summary>
/// Private helper method removes Owner instance from the DB.
/// </summary>
/// <param name="owner"></param>
/// <returns></returns>
private bool RemoveOwner(Owner owner)
{
return(LogicBroker.RemoveEntity <Owner>(owner));
}
