private void LoadDataUpdateHomeAsSold(int homeID)
{
HomeSale hfsHomesale = ((App)Application.Current)._homeSalesCollection.Where(
hs =>
hs.HomeID == homeID &&
hs.MarketDate != null &&
hs.SoldDate == null).FirstOrDefault();
Home hfsHome = ((App)Application.Current)._homesCollection.Where(h => h.HomeID == homeID).FirstOrDefault();
if (hfsHome != null && hfsHomesale != null)
{
Person hfsAgent = new Person();
hfsAgent = ((App)Application.Current)._peopleCollection.Where(p => p.PersonID == hfsHomesale.AgentID).FirstOrDefault();
if (hfsAgent != null && hfsAgent.Agent.CompanyID != null)
{
RealEstateCompany hfsReco = new RealEstateCompany();
hfsReco = ((App)Application.Current)._recosCollection.Where(r => r.CompanyID == hfsAgent.Agent.CompanyID).FirstOrDefault();
if (hfsReco != null)
{
UpdatePerson = hfsAgent;
UpdateAgent = hfsAgent.Agent;
UpdateHome = hfsHome;
UpdateHomeSale = hfsHomesale;
UpdateReco = hfsReco;
}
}
}
}
private void UpdateYearMonthTotalSold(HomeSale sale)
{
int year = sale.SaleDate.Year;
int month = sale.SaleDate.Month;
int schoolCode = sale.SchoolCode; // assumed as int
// if year is not there, new dictionary is added. otherwise, we can assume value with the key is already there
YearMonthTotalValueSold.TryAdd(
year, new ConcurrentDictionary <int, ConcurrentDictionary <int, decimal> >());
// if month is not there, new dictionary is added. otherwise, we can assume value with the key is already there
YearMonthTotalValueSold[year]
.TryAdd(month, new ConcurrentDictionary <int, decimal>());
bool hasSchoolAdded = YearMonthTotalValueSold[year][month].TryAdd(schoolCode, sale.Price);
if (!hasSchoolAdded)
{
// this school has already entry, update accumlated price
lock (yearmonthlock)
{
YearMonthTotalValueSold[year][month][sale.SchoolCode] =
YearMonthTotalValueSold[year][month][sale.SchoolCode] + sale.Price;
}
}
}
public void Add(HomeSale homeSales)
{
var re = _homeSales.SingleOrDefault(hs => hs.HomeID == homeSales.HomeID);
if (re == null)
{
_homeSales.Add(homeSales);
}
}
private void ProcessLineAndAddToConcurrentBag(string line)
{
HomeSale sale = ProcessLine(line);
if (sale != null)
{
listOfHomeSales.Add(sale);
SchoolCodeNameMap.TryAdd(sale.SchoolCode, sale.SchoolDescription);
UpdateYearMonthTotalSold(sale);
UpdateAverageNumOfDays(sale);
}
}
//we can make HomeSale as a struct for performance reasons
// In that case, when bad input is in the line, throw exception.
private HomeSale ProcessLine(string line)
{
//TODO: remove this line
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
// delimiter of this file is tab; so, thats what we will use;
// We should take this delimitor from config as well
string[] splitContent = line.Split(delimitor.ToCharArray());
if (splitContent.Length != 6)
{
// log the line and return
return(null);
}
string propertyZip = splitContent[0];
if (!int.TryParse(splitContent[1], out var schoolCode))
{
//log the issue and return; we will not consider this line
return(null);
}
string schoolName = splitContent[2];
if (!DateTime.TryParse(splitContent[3], out var record))
{
//log the issue and return; we will not consider this line
return(null);
}
// we can add more date validations about the range of the value
if (!DateTime.TryParse(splitContent[4], out var saleDt))
{
//log the issue and return; we will not consider this line
return(null);
}
// we can add more date validations about the range of the value
if (!decimal.TryParse(splitContent[5], out var priceOfSale))
{
//log the issue and return; we will not consider this line
return(null);
}
HomeSale sale = new HomeSale(propertyZip, schoolCode, schoolName, record, saleDt, priceOfSale);
return(sale);
}
private void LoadDataPutHomeOnMarket(int homeID)
{
UpdateHome = ((App)Application.Current)._homesCollection.Where(h => h.HomeID == homeID).FirstOrDefault();
if (UpdateHome == null)
{
// theoretically a null UpdateHome will cause the Window to only allow user to close it
UpdateHome = new Home();
}
UpdateAgent = new Agent();
UpdatePerson = new Person();
UpdateHomeSale = new HomeSale();
UpdateReco = new RealEstateCompany();
}
private void UpdateAverageNumOfDays(HomeSale sale)
{
int year = sale.SaleDate.Year;
int month = sale.SaleDate.Month;
int schoolCode = sale.SchoolCode;
int numberOfDays = (sale.RecordDate - sale.SaleDate).Days;
AverageNumOfDays.TryAdd(year, new ConcurrentDictionary <int, ConcurrentDictionary <int, TotalDaysNumberOfSales> >());
AverageNumOfDays[year].TryAdd(month, new ConcurrentDictionary <int, TotalDaysNumberOfSales>());
//if this sale is the first one, we want to add 1, numberofdays
bool hasAdded = AverageNumOfDays[year][month]
.TryAdd(schoolCode, new TotalDaysNumberOfSales(1, numberOfDays));
if (!hasAdded)
{
lock (averageDaysLock)
{
TotalDaysNumberOfSales days = AverageNumOfDays[year][month][schoolCode];
TotalDaysNumberOfSales newValue = new TotalDaysNumberOfSales(days.NumberOfSales + 1, days.TotalNumberOfDays + numberOfDays);
AverageNumOfDays[year][month][schoolCode] = newValue;
}
}
}
private void SaveChangesButton_Click(object sender, RoutedEventArgs e)
{
try
{
int savedCount = 0;
string updateType = UpdateType.Trim().ToUpper();
switch (updateType)
{
case "PUTONMARKET":
{
savedCount += ((App)Application.Current)._homeSalesCollection.Add(UpdateHomeSale);
break;
}
case "HOMESOLD":
{
if (BuyerUpdated && HomesaleUpdated)
{
Person buyerPerson = ((App)Application.Current)._peopleCollection.Get(UpdateBuyer.BuyerID);
if (buyerPerson == null)
{
break;
}
savedCount += ((App)Application.Current)._peopleCollection.UpdatePerson(buyerPerson);
var homesaleToSave = new HomeSale()
{
SaleID = UpdateHomeSale.SaleID,
HomeID = UpdateHomeSale.HomeID,
SoldDate = UpdateHomeSale.SoldDate,
AgentID = UpdateHomeSale.AgentID,
SaleAmount = UpdateHomeSale.SaleAmount,
BuyerID = UpdateBuyer.BuyerID,
MarketDate = UpdateHomeSale.MarketDate,
CompanyID = UpdateHomeSale.CompanyID
};
savedCount += ((App)Application.Current)._homeSalesCollection.Update(homesaleToSave);
}
break;
}
default:
{
DisplayStatusMessage("Nothing was saved.");
ShowCloseButtonOnly();
break;
}
}
if (savedCount < 1)
{
DisplayStatusMessage("Home or Home Sale info required for: Agent, Buyer, and Owner changes.");
}
if (savedCount > 0)
{
DisplayStatusMessage("Save completed! Click Close to exit.");
IsButtonClose = true;
}
}
catch (Exception ex)
{
DisplayStatusMessage("Unable to save changes.");
logger.Data("Home Updater Window Exception Caught!", ex.Message);
logger.Flush();
logger.Data("UpdateHome: ", UpdateHome?.ToString());
logger.Flush();
logger.Data("UpdateRealEstateCompany: ", UpdateReco?.ToString());
logger.Flush();
logger.Data("UpdateHomeSale (Market): ", UpdateHomeSale?.ToString());
logger.Flush();
logger.Data("UpdateBuyer: ", $"{ UpdateBuyer?.ToString() }");
logger.Flush();
logger.Data("UpdatedHomeSale (Sold): ", $"{ UpdateHomeSale?.ToString() }");
logger.Flush();
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (CheckAgent.IsChecked.HasValue && (bool)CheckAgent.IsChecked)
{
try
{
//TODO: only allow home to be listed once
Person personObject = new Person();
HomeTrackerDatamodelLibrary.Agent agentObject = new HomeTrackerDatamodelLibrary.Agent();
personObject.FirstName = firstName.Text;
personObject.LastName = lastName.Text;
personObject.Phone = phoneNumber.Text;
personObject.Email = email.Text;
decimal commPerc;
if (!decimal.TryParse(comissionPercentage.Text, out commPerc))
{
// TODO: Notify user of failure
return;
}
agentObject.CommissionPercent = commPerc;
if (CompanyListBox.SelectedIndex == -1)
{
return;
}
agentObject.CompanyID = (int)CompanyListBox.SelectedValue;
personObject.Agent = agentObject;
peopleUd.Add(personObject);
HomeSale homeSalesObject = new HomeSale();
if (HomeListBox.SelectedIndex == -1)
{
return;
//todo tell user we cannot add the home
}
homeSalesObject.HomeID = (int)HomeListBox.SelectedValue;
homeSalesObject.AgentID = personObject.Agent.AgentID;
homeSalesObject.MarketDate = DateTime.Now;
//homeSalesObject.CompanyID = personObject.Agent.CompanyID;
homeSalesObject.CompanyID = (int)CompanyListBox.SelectedValue;//fix this
decimal SAmount;
if (!decimal.TryParse(SaleAmount.Text, out SAmount))
{
// TODO: Notify user of failure
return;
}
homeSalesObject.SaleAmount = SAmount;
homeSalesCollection.Add(homeSalesObject);
}
catch(Exception ex)
{
}
}
else if(CheckBuyer.IsChecked.HasValue && (bool)CheckBuyer.IsChecked)
{
try
{
Person personObject = new Person();
HomeTrackerDatamodelLibrary.Buyer buyerObject = new HomeTrackerDatamodelLibrary.Buyer();
personObject.FirstName = firstNameB.Text;
personObject.LastName = lastNameB.Text;
personObject.Phone = phoneNumberB.Text;
personObject.Email = emailB.Text;
int credRate;
if (!int.TryParse(creditRatingB.Text, out credRate))
{
return;
}
buyerObject.CreditRating = credRate;
personObject.Buyer = buyerObject;
peopleUd.Add(personObject);
if (HomeListBox.SelectedIndex == -1)
{
return;
//todo tell user we cannot add the home
}
int selectedHomeID = (int)HomeListBox.SelectedValue;
homeSaleToSold = (from hs in homeSalesCollection
where hs.HomeID == selectedHomeID
select hs).First();
homeSaleToSold.SoldDate = DateTime.Now;
homeSaleToSold.BuyerID = personObject.Buyer.BuyerID;
homeSalesCollection.Update(homeSaleToSold);
}
catch (Exception ex)
{
//TODO: notify user
}
}
this.Close();
}
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
}
}
}
