private OperationStatus setupOperationStatus(Person p)
        {
            var opStatus = new OperationStatus();
            opStatus.Data = p;

            return opStatus;
        }
        public OperationStatus DeletePerson(Person person)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork())
                {
                    if (person.Phones != null)
                    {
                        foreach (Phone phone in person.Phones)
                            unitOfWork.Phones.Delete(phone);

                        person.Phones = null;
                    }

                    if (person.Addresses != null)
                    {
                        foreach (PersonAddressAssn addressAssn in person.Addresses)
                            unitOfWork.PersonAddressAssns.Delete(addressAssn);

                        person.Addresses = null;
                    }

                    unitOfWork.Persons.Delete(person);
                    unitOfWork.Commit();
                }

                return new OperationStatus { Success = true };
            }
            catch (Exception e)
            {
                return OperationStatus.CreateFromException("Error deleting person.", e);
            }
        }
        public ActionResult New()
        {           
            var person = new Person();

            person.PersonID = 0;
            person.FirstName = string.Empty;
            person.LastName = string.Empty;
            person.EmailAddress = string.Empty;

            person.Phones = new List<Phone>();
            person.Phones.Add(new Phone { PhoneTypeID = 1, Number = string.Empty });
            person.Phones.Add(new Phone { PhoneTypeID = 2, Number = string.Empty });
            person.Phones.Add(new Phone { PhoneTypeID = 3, Number = string.Empty });

            var emptyAddress = new Address
            {
                StreetAddress = string.Empty,
                City = string.Empty,
                State = string.Empty,
                Zip = string.Empty
            };

            person.Addresses = new List<PersonAddressAssn>();
            person.Addresses.Add(new PersonAddressAssn { AddressTypeID = 1, Address = emptyAddress });
            person.Addresses.Add(new PersonAddressAssn { AddressTypeID = 2, Address = emptyAddress });
            person.Addresses.Add(new PersonAddressAssn { AddressTypeID = 3, Address = emptyAddress });

            ViewBag.States = stateSelectList();

            return PartialView("Edit", person);
        }
        public void TestPersonSave()
        {
            PersonController personController = new PersonController(mockPersonService.Object);

            var person = new Person();
            person.PersonID = 1;
            person.FirstName = "Pam";
            person.LastName = "Scicchitano";
            person.EmailAddress = "*****@*****.**";

            ActionResult result = personController.Save(person);

            // Verify that the result is of type ContentResult
            Assert.IsInstanceOf<ContentResult>(result);
        }
        public OperationStatus DeletePerson(Person person)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork())
                {
                    unitOfWork.Persons.Delete(person);
                    unitOfWork.Commit();
                }

                return new OperationStatus { Success = true };
            }
            catch (Exception e)
            {
                return OperationStatus.CreateFromException("Error deleting person.", e);
            }
        }
        public ContentResult Save(Person person)
        {            
            if (person.PersonID == 0)
            {
                var opStatus = personService.InsertPerson(person);

                return Content("The person has been created in the system.");
            }                
            else
            {
                var opStatus = personService.UpdatePerson(person);

                return Content("The person has been updated");                
            }
        }
        public OperationStatus UpdatePerson(Person updatedPerson)
        {
            try
            {                          
                using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork())
                {                    
                    var person = unitOfWork.Persons.Update(updatedPerson);
                    unitOfWork.Commit();

                    var json = serializePersonToPersonDocumentJson(person);
                    notificationService.SendPersonUpdatedNotification(person.PersonID, json);

                    return new OperationStatus { Success = true, Data = person };
                }                                    
            }
            catch (Exception e)
            {
                return OperationStatus.CreateFromException("Error updating person.", e);
            }
        }
        public void TestInsertPerson()
        {
            var testUoW = new FootlooseFSTestUnitOfWork();
            var mockUoWFactory = new Mock<IFootlooseFSUnitOfWorkFactory>();
            var mockNotificationService = new Mock<IFootlooseFSNotificationService>();

            // Instead of instantiating a new UoW object in the factory we want to use the one we created so we can monitor
            // it's internal data and verify that the service did what is was supposed to do
            mockUoWFactory.Setup(m => m.CreateUnitOfWork()).Returns(testUoW);

            mockNotificationService.Setup(m => m.SendPersonUpdatedNotification(It.IsAny<int>(), It.IsAny<string>())).Returns(true);

            var uowFactory = mockUoWFactory.Object;
            var service = new FootlooseFSService(uowFactory, mockNotificationService.Object);

            var person = new Person
            {
                PersonID = 5,
                FirstName = "John",
                LastName = "Dorman",
                EmailAddress = "*****@*****.**", // Updated email address
                Phones = new List<Phone>
                {
                    new Phone
                    {
                        PersonID = 5,
                        Number = "813-657-2222",    // Update home phone
                        PhoneType = new PhoneType { Name = "Home", PhoneTypeID = 1 },
                        PhoneTypeID = 1
                    }
                },
                Addresses = new List<PersonAddressAssn>
                {
                    new PersonAddressAssn
                    {
                        Address = new Address
                        {
                            StreetAddress = "823 Newton Drive",   // Updated address
                            State = "FL",
                            Zip = "33782",
                            AddressID = 5,
                            City = "Pinellas Park"
                        },
                        AddressID = 5,
                        AddressType = new AddressType { Name = "Home", AddressTypeID = 1 },
                        AddressTypeID = 1,
                        PersonID = 5
                    }
                },
            };

            var opStatus = service.InsertPerson(person);

            var insertedPerson = (Person)opStatus.Data;

            // Verify that the InsertPerson method returns data of type Person
            Assert.IsInstanceOf<Person>(insertedPerson);

            // Get the inserted person object from the UoW
            var insertedPersonFromUoW = testUoW.Persons.GetQueryable().Where(p => p.PersonID == 5).First();

            // Verify that email address was applied
            Assert.AreEqual(insertedPersonFromUoW.EmailAddress, "*****@*****.**");

            // Verify that the home phone number was updated
            var homePhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 1).FirstOrDefault();
            Assert.AreEqual(homePhone.Number, "813-657-2222");

            // Verify that there is no work number
            var workPhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 2);
            Assert.AreEqual(workPhone.Count(), 0);

            // Verify that there is no cell number
            var cellPhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 3);
            Assert.AreEqual(cellPhone.Count(), 0);

            // Verify that the address was updated
            var address = insertedPersonFromUoW.Addresses.Where(a => a.AddressTypeID == 1).FirstOrDefault().Address;

            Assert.AreEqual(address.StreetAddress, "823 Newton Drive");
            Assert.AreEqual(address.City, "Pinellas Park");
            Assert.AreEqual(address.Zip, "33782");
            Assert.AreEqual(address.State, "FL");
        }
        public JsonResult Save(FormCollection formCollection)
        {
            var person = new Person();

            int personID = 0;
            Int32.TryParse(formCollection["personID"], out personID);

            person.PersonID = personID;
            person.FirstName = formCollection["firstName"];
            person.LastName = formCollection["lastName"];
            person.EmailAddress = formCollection["emailAddress"];

            person.Phones = new List<Phone>();
            person.Phones.Add(new Phone { PersonID = personID, PhoneTypeID = (int)PhoneTypes.Home, Number = formCollection["homePhone"] });
            person.Phones.Add(new Phone { PersonID = personID, PhoneTypeID = (int)PhoneTypes.Work, Number = formCollection["workPhone"] });
            person.Phones.Add(new Phone { PersonID = personID, PhoneTypeID = (int)PhoneTypes.Cell, Number = formCollection["cellPhone"] });

            person.Addresses = new List<PersonAddressAssn>();

            if (!string.IsNullOrEmpty(formCollection["homeStreetAddress"]))
            {
                var address = new Address();

                int homeAddressID = 0;
                Int32.TryParse(formCollection["homeAddressID"], out homeAddressID);
                address.AddressID = homeAddressID;

                address.StreetAddress = formCollection["homeStreetAddress"];
                address.City = formCollection["homeCity"];
                address.State = formCollection["homeState"];
                address.Zip = formCollection["homeZip"];

                person.Addresses.Add(new PersonAddressAssn { PersonID = personID, AddressID = homeAddressID, Address = address, AddressTypeID = (int)AddressTypes.Home });
            }

            if (!string.IsNullOrEmpty(formCollection["workStreetAddress"]))
            {
                var address = new Address();

                int workAddressID = 0;
                Int32.TryParse(formCollection["workAddressID"], out workAddressID);
                address.AddressID = workAddressID;

                address.StreetAddress = formCollection["workStreetAddress"];
                address.City = formCollection["workCity"];
                address.State = formCollection["workState"];
                address.Zip = formCollection["workZip"];

                person.Addresses.Add(new PersonAddressAssn { PersonID = personID, AddressID = workAddressID, Address = address, AddressTypeID = (int)AddressTypes.Work });
            }

            if (!string.IsNullOrEmpty(formCollection["altStreetAddress"]))
            {
                var address = new Address();

                int altAddressID = 0;
                Int32.TryParse(formCollection["altAddressID"], out altAddressID);
                address.AddressID = altAddressID;

                address.StreetAddress = formCollection["altStreetAddress"];
                address.City = formCollection["altCity"];
                address.State = formCollection["altState"];
                address.Zip = formCollection["altZip"];

                person.Addresses.Add(new PersonAddressAssn { PersonID = personID, AddressID = altAddressID, Address = address, AddressTypeID = (int)AddressTypes.Alternate });
            }

            if (person.PersonID == 0)
            {
                var opStatus = _footlooseFSService.InsertPerson(person);

                var newPerson = (Person)opStatus.Data;

                var savePersonResult = new SavePersonResult
                    {
                        Message = "The person has been created in the system.",
                        Person = newPerson,
                        PersonID = newPerson.PersonID,
                        HomeAddressID = newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Home).Any() ?
                                        newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Home).First().AddressID : 0,
                        WorkAddressID = newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Work).Any() ?
                                        newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Work).First().AddressID : 0,
                        AlternateAddressID = newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Alternate).Any() ?
                                        newPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Alternate).First().AddressID : 0,
                    };

                return Json(savePersonResult);
            }
            else
            {
                var opStatus = _footlooseFSService.UpdatePerson(person);

                var updatedPerson = (Person)opStatus.Data;

                var savePersonResult = new SavePersonResult
                {
                    Message = "The person has been updated",
                    Person = updatedPerson,
                    PersonID = updatedPerson.PersonID,
                    HomeAddressID = updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Home).Any() ?
                                    updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Home).First().AddressID : 0,
                    WorkAddressID = updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Work).Any() ?
                                    updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Work).First().AddressID : 0,
                    AlternateAddressID = updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Alternate).Any() ?
                                    updatedPerson.Addresses.Where(a => a.AddressTypeID == (int)AddressTypes.Alternate).First().AddressID : 0,
                };

                return Json(savePersonResult);
            }
        }
 public OperationStatus DeletePerson(Person person)
 {
     return footlooseService.DeletePerson(person);
 }
        public void TestUpdatePerson()
        {
            var testUoW = new FootlooseFSTestUnitOfWork();
            var mockUoWFactory = new Mock<IFootlooseFSUnitOfWorkFactory>();
            var mockNotificationService = new Mock<IFootlooseFSNotificationService>();

            // Instead of instantiating a new UoW object in the factory we want to use the one we created so we can monitor
            // it's internal data and verify that the service did what is was supposed to do
            mockUoWFactory.Setup(m => m.CreateUnitOfWork()).Returns(testUoW);

            mockNotificationService.Setup(m => m.SendPersonUpdatedNotification(It.IsAny<int>(), It.IsAny<string>())).Returns(true);

            var uowFactory = mockUoWFactory.Object;
            var service = new FootlooseFSService(uowFactory, mockNotificationService.Object);

            var person = new Person
            {
                PersonID = 1,
                FirstName = "Pam",
                LastName = "Scicchitano",
                EmailAddress = "*****@*****.**", // Updated email address
                Phones = new List<Phone>
                {
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-5555",    // Update home phone
                        PhoneType = new PhoneType { Name = "Home", PhoneTypeID = 1 },
                        PhoneTypeID = 1
                    },
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-7777",    // Updated work phone
                        PhoneType = new PhoneType { Name = "Work", PhoneTypeID = 2 },
                        PhoneTypeID = 2
                    },
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-4444",    // Updated cell phone
                        PhoneType = new PhoneType { Name = "Cell", PhoneTypeID = 3 },
                        PhoneTypeID = 3
                    }
                },
                Addresses = new List<PersonAddressAssn>
                {
                    new PersonAddressAssn
                    {
                        Address = new Address
                        {
                            StreetAddress = "631 Glebe Road",   // Updated address
                            State = "VA",
                            Zip = "20178",
                            AddressID = 1,
                            City = "Arlington"
                        },
                        AddressID = 1,
                        AddressType = new AddressType { Name = "Home", AddressTypeID = 1 },
                        AddressTypeID = 1,
                        PersonID = 1
                    }
                },
            };

            var opStatus = service.UpdatePerson(person);

            var updatedPerson = (Person)opStatus.Data;

            // Verify that the UpdatePerson method returns data of type Person
            Assert.IsInstanceOf<Person>(updatedPerson);

            // Get the updated person object from the UoW
            var updatedPersonFromUoW = testUoW.Persons.GetQueryable().Where(p => p.PersonID == 1).First();

            // Verify that email address was updated
            Assert.AreEqual(updatedPersonFromUoW.EmailAddress, "*****@*****.**");

            // Verify that the home phone number was updated
            var homePhone = updatedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 1).FirstOrDefault();
            Assert.AreEqual(homePhone.Number, "336-418-5555");

            // Verify that the work number was updated
            var workPhone = updatedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 2).FirstOrDefault();
            Assert.AreEqual(workPhone.Number, "336-418-7777");

            // Verify that the cell number was updated
            var cellPhone = updatedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 3).FirstOrDefault();
            Assert.AreEqual(cellPhone.Number, "336-418-4444");

            // Verify that the address was updated
            var address = updatedPersonFromUoW.Addresses.Where(a => a.AddressTypeID == 1).FirstOrDefault().Address;

            Assert.AreEqual(address.StreetAddress, "631 Glebe Road");
            Assert.AreEqual(address.City, "Arlington");
            Assert.AreEqual(address.Zip, "20178");
            Assert.AreEqual(address.State, "VA");
        }
 public OperationStatus UpdatePerson(Person person)
 {
     return footlooseService.UpdatePerson(person);
 }
        private string serializePersonToPersonDocumentJson(Person person)
        {
            var personDocument = new PersonDocument();

            personDocument.PersonID = person.PersonID;
            personDocument.EmailAddress = person.EmailAddress;
            personDocument.FirstName = person.FirstName;
            personDocument.LastName = person.LastName;
            personDocument.PhoneNumber = person.Phones.Any(p => p.PhoneTypeID == 1) ? person.Phones.First(p => p.PhoneTypeID == 1).Number : string.Empty;

            var address = person.Addresses.Any(a => a.AddressTypeID == 1) ? person.Addresses.First(a => a.AddressTypeID == 1).Address : null;
            if (address != null)
            {
                personDocument.StreetAddress = address.StreetAddress;
                personDocument.City = address.City;
                personDocument.State = address.State;
                personDocument.Zip = address.Zip;
            }

            return JsonConvert.SerializeObject(personDocument);
        }
        static public List<Person> GetPersonTestData()
        {
            List<Person> persons = new List<Person>();

            var person = new Person
            {
                PersonID = 1,
                FirstName = "Pam",
                LastName = "Scicchitano",
                EmailAddress = "*****@*****.**",
                Phones = new List<Phone>
                {
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-5159",
                        PhoneType = new PhoneType { Name = "Home", PhoneTypeID = 1 },
                        PhoneTypeID = 1
                    },                    
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-4000",
                        PhoneType = new PhoneType { Name = "Work", PhoneTypeID = 2 },
                        PhoneTypeID = 2
                    },
                    new Phone
                    {
                        PersonID = 1,
                        Number = "336-418-6000",
                        PhoneType = new PhoneType { Name = "Cell", PhoneTypeID = 3 },
                        PhoneTypeID = 3
                    }
                },
                Addresses = new List<PersonAddressAssn>
                {
                    new PersonAddressAssn
                    {
                        Address = new Address
                        {
                            StreetAddress = "38 S Dunworth St #4185",
                            State = "NC",
                            Zip = "27215",
                            AddressID = 1,
                            City = "Raleigh"
                        },
                        AddressID = 1,
                        AddressType = new AddressType { Name = "Home", AddressTypeID = 1 },
                        AddressTypeID = 1,
                        PersonID = 1
                    }
                },                
            };

            persons.Add(person);

            person = new Person
            {
                PersonID = 2,
                FirstName = "Dominique",
                LastName = "Marantz",
                EmailAddress = "*****@*****.**",
                Phones = new List<Phone>
                {
                    new Phone
                    {
                        PersonID = 2,
                        Number = "223-564-5159",
                        PhoneType = new PhoneType { Name = "Home", PhoneTypeID = 1 },
                        PhoneTypeID = 1
                    },                    
                    new Phone
                    {
                        PersonID = 2,
                        Number = "223-564-4000",
                        PhoneType = new PhoneType { Name = "Work", PhoneTypeID = 2 },
                        PhoneTypeID = 1
                    },
                    new Phone
                    {
                        PersonID = 2,
                        Number = "223-564-6000",
                        PhoneType = new PhoneType { Name = "Cell", PhoneTypeID = 3 },
                        PhoneTypeID = 1
                    }
                },
                Addresses = new List<PersonAddressAssn>
                {
                    new PersonAddressAssn
                    {
                        Address = new Address
                        {
                            StreetAddress = "94 Sunland Court",
                            State = "FL",
                            Zip = "33997",
                            AddressID = 2,
                            City = "Ft. Lauderdale"
                        },
                        AddressID = 2,
                        AddressType = new AddressType { Name = "Home", AddressTypeID = 1 },
                        AddressTypeID = 1,
                        PersonID = 2
                    }
                },
            };

            persons.Add(person);

            return persons;
        }
        private void updatePhone(Person person, Person updatedPerson, int phoneType, IFootlooseFSUnitOfWork unitOfWork)
        {
            var updatePhone = updatedPerson.Phones.Where(p => p.PhoneTypeID == phoneType).FirstOrDefault();
            if (updatePhone == null)
            {
                var phone = person.Phones.Where(p => p.PhoneTypeID == phoneType).FirstOrDefault();
                if (phone != null)
                    unitOfWork.Phones.Delete(phone);
            }
            else
            {
                var phone = person.Phones.Where(p => p.PhoneTypeID == phoneType).FirstOrDefault();
                if (phone == null)
                {
                    phone = new Phone();
                    phone.PersonID = updatePhone.PersonID;
                    phone.PhoneTypeID = updatePhone.PhoneTypeID;
                    person.Phones.Add(phone);
                }

                phone.Number = updatePhone.Number;
            }
        }
        private void updateAddress(Person person, Person updatedPerson, int addressType, IFootlooseFSUnitOfWork unitOfWork)
        {
            var updatedAddressAssn = updatedPerson.Addresses.Where(a => a.AddressTypeID == addressType).FirstOrDefault();
            if (updatedAddressAssn == null)
            {
                var addressAssn = person.Addresses.Where(a => a.AddressTypeID == addressType).FirstOrDefault();
                if (addressAssn != null)
                {
                    unitOfWork.Addresses.Delete(addressAssn.Address);
                    unitOfWork.PersonAddressAssns.Delete(addressAssn);
                }
            }
            else
            {
                var addressAssn = person.Addresses.Where(a => a.AddressTypeID == addressType).FirstOrDefault();
                if (addressAssn == null)
                {
                    addressAssn = new PersonAddressAssn();
                    addressAssn.PersonID = updatedAddressAssn.PersonID;
                    addressAssn.AddressTypeID = updatedAddressAssn.AddressTypeID;
                    addressAssn.Address = new Address();

                    person.Addresses.Add(addressAssn);

                }

                addressAssn.Address.StreetAddress = updatedAddressAssn.Address.StreetAddress;
                addressAssn.Address.City = updatedAddressAssn.Address.City;
                addressAssn.Address.State = updatedAddressAssn.Address.State;
                addressAssn.Address.Zip = updatedAddressAssn.Address.Zip;
            }
        }
        public OperationStatus InsertPerson(Person person)
        {
            try
            {
                // Use the ValidationContext to validate the Product model against the product data annotations
                // before saving it to the database
                var validationContext = new ValidationContext(person, serviceProvider: null, items: null);
                var validationResults = new List<ValidationResult>();

                var isValid = Validator.TryValidateObject(person, validationContext, validationResults, true);

                // If there any exception return them in the return result
                if (!isValid)
                {
                    OperationStatus opStatus = new OperationStatus();
                    opStatus.Success = false;

                    foreach (ValidationResult message in validationResults)
                    {
                        opStatus.Messages.Add(message.ErrorMessage);
                    }

                    return opStatus;
                }
                else
                {
                    // Otherwise connect to the data source using the db context and save the
                    // person to the database
                    using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork())
                    {
                        unitOfWork.Persons.Add(person);
                        unitOfWork.Commit();
                    }

                    return new OperationStatus { Success = true, Data = person };
                }
            }
            catch (Exception e)
            {
                return OperationStatus.CreateFromException("Error inserting person.", e);
            }
        }
        public OperationStatus UpdatePerson(Person updatedPerson)
        {
            try
            {
                // Use the ValidationContext to validate the Product model against the product data annotations
                // before saving it to the database
                var validationContext = new ValidationContext(updatedPerson, serviceProvider: null, items: null);
                var validationResults = new List<ValidationResult>();

                var isValid = Validator.TryValidateObject(updatedPerson, validationContext, validationResults, true);

                // If there any exception return them in the return result
                if (!isValid)
                {
                    OperationStatus opStatus = new OperationStatus();
                    opStatus.Success = false;

                    foreach (ValidationResult message in validationResults)
                    {
                        opStatus.Messages.Add(message.ErrorMessage);
                    }

                    return opStatus;
                }
                else
                {
                    // Otherwise connect to the data source using the db context and save the
                    // person to the database
                    Person person;

                    using (var unitOfWork = unitOfWorkFactory.CreateUnitOfWork())
                    {
                        person = unitOfWork.Persons.GetQueryable().Where(p => p.PersonID == updatedPerson.PersonID)
                                            .Include("Addresses.Address")
                                            .Include("Phones")
                                            .First();

                        person.FirstName = updatedPerson.FirstName;
                        person.LastName = updatedPerson.LastName;
                        person.EmailAddress = updatedPerson.EmailAddress;

                        updatePhone(person, updatedPerson, (int)PhoneTypes.Home, unitOfWork);
                        updatePhone(person, updatedPerson, (int)PhoneTypes.Work, unitOfWork);
                        updatePhone(person, updatedPerson, (int)PhoneTypes.Cell, unitOfWork);

                        updateAddress(person, updatedPerson, (int)AddressTypes.Home, unitOfWork);
                        updateAddress(person, updatedPerson, (int)AddressTypes.Work, unitOfWork);
                        updateAddress(person, updatedPerson, (int)AddressTypes.Alternate, unitOfWork);

                        unitOfWork.Persons.Update(person);
                        unitOfWork.Commit();
                    }

                    return new OperationStatus { Success = true, Data = person };
                }
            }
            catch (Exception e)
            {
                return OperationStatus.CreateFromException("Error updating person.", e);
            }
        }
        public void TestInsertAndDeletePerson()
        {
            var uowFactory = new FootlooseFSSqlUnitOfWorkFactory();
            var notificationService = new FootlooseFSNotificationService();
            var service = new FootlooseFSService(uowFactory, notificationService);

            var person = new Person
            {
                FirstName = "John",
                LastName = "Dorman",
                EmailAddress = "*****@*****.**", // Updated email address
                Phones = new List<Phone>
                {
                    new Phone
                    {
                        Number = "813-657-2222",    // Update home phone
                        PhoneTypeID = 1
                    }
                },
                Addresses = new List<PersonAddressAssn>
                {
                    new PersonAddressAssn
                    {
                        Address = new Address
                        {
                            StreetAddress = "823 Newton Drive",   // Updated address
                            State = "FL",
                            Zip = "33782",
                            AddressID = 5,
                            City = "Pinellas Park"
                        },
                        AddressTypeID = 1,
                    }
                },
            };

            var opStatus = service.InsertPerson(person);

            var insertedPerson = (Person)opStatus.Data;

            // Verify that the InsertPerson method returns data of type Person
            Assert.IsInstanceOf<Person>(insertedPerson);

            var insertedPersonFromUoW = service.GetPersonById(insertedPerson.PersonID, new PersonIncludes { Phones = true, Addressses = true });

            // Verify that email address was applied
            Assert.AreEqual(insertedPersonFromUoW.EmailAddress, "*****@*****.**");

            // Verify that the home phone number was updated
            var homePhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 1).FirstOrDefault();
            Assert.AreEqual(homePhone.Number, "813-657-2222");

            // Verify that there is no work number
            var workPhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 2 && ! string.IsNullOrEmpty(p.Number));
            Assert.AreEqual(workPhone.Count(), 0);

            // Verify that there is no cell number
            var cellPhone = insertedPersonFromUoW.Phones.Where(p => p.PhoneTypeID == 3 && !string.IsNullOrEmpty(p.Number));
            Assert.AreEqual(cellPhone.Count(), 0);

            // Verify that the address was updated
            var address = insertedPersonFromUoW.Addresses.Where(a => a.AddressTypeID == 1).FirstOrDefault().Address;

            Assert.AreEqual(address.StreetAddress, "823 Newton Drive");
            Assert.AreEqual(address.City, "Pinellas Park");
            Assert.AreEqual(address.Zip, "33782");
            Assert.AreEqual(address.State, "FL");

            // Now delete the person
            service.DeletePerson(insertedPersonFromUoW);

            // Make sure the person is deleted
            var deletedPerson = service.GetPersonById(insertedPersonFromUoW.PersonID, new PersonIncludes());

            Assert.IsNull(deletedPerson);
        }
 public OperationStatus InsertPerson(Person person)
 {
     return footlooseService.InsertPerson(person);
 }