Click here to Skip to main content
Click here to Skip to main content
Articles » Web Development » ASP.NET » General » Downloads
 
Add your own
alternative version
Go to top

Design and Develop a website using ASP.NET MVC 4, EF, Knockoutjs and Bootstrap : Part - 2

, 13 Jan 2013
Design a website architecture that must be simple, easily understandable by any web designer using asp.net MVC, EF, Knockoutjs and Bootstrap
Application-noexe.zip
Application
Application
.nuget
NuGet.targets
Application.Common
Application.Common.csproj.user
Logging
Properties
Resources
Validator
Application.Core
ProfileModule
AddressAggregate
PhoneAggregate
ProfileAddressAggregate
ProfileAggregate
ProfilePhoneAggregate
Properties
Resources
Specification
Common
Contract
Implementation
Application.DAL
Contract
EntityConfiguration
Properties
Resources
Application.DTO
ProfileModule
Properties
Application.Manager
Contract
Conversion
Implementation
Properties
Resources
Application.Repository
ProfileModule
Properties
Application.v11.suo
Application.Web
App_Start
Application.Web.csproj.user
Content
images
glyphicons-halflings-white.png
glyphicons-halflings.png
themes
base
images
ui-bg_flat_0_aaaaaa_40x100.png
ui-bg_flat_75_ffffff_40x100.png
ui-bg_glass_55_fbf9ee_1x400.png
ui-bg_glass_65_ffffff_1x400.png
ui-bg_glass_75_dadada_1x400.png
ui-bg_glass_75_e6e6e6_1x400.png
ui-bg_glass_95_fef1ec_1x400.png
ui-bg_highlight-soft_75_cccccc_1x100.png
ui-icons_222222_256x240.png
ui-icons_2e83ff_256x240.png
ui-icons_454545_256x240.png
ui-icons_888888_256x240.png
ui-icons_cd0a0a_256x240.png
minified
images
ui-bg_flat_0_aaaaaa_40x100.png
ui-bg_flat_75_ffffff_40x100.png
ui-bg_glass_55_fbf9ee_1x400.png
ui-bg_glass_65_ffffff_1x400.png
ui-bg_glass_75_dadada_1x400.png
ui-bg_glass_75_e6e6e6_1x400.png
ui-bg_glass_95_fef1ec_1x400.png
ui-bg_highlight-soft_75_cccccc_1x100.png
ui-icons_222222_256x240.png
ui-icons_2e83ff_256x240.png
ui-icons_454545_256x240.png
ui-icons_888888_256x240.png
ui-icons_cd0a0a_256x240.png
Controllers
Dependency
favicon.ico
Filters
Global.asax
Images
accent.png
bullet.png
heroAccent.png
orderedList0.png
orderedList1.png
orderedList2.png
orderedList3.png
orderedList4.png
orderedList5.png
orderedList6.png
orderedList7.png
orderedList8.png
orderedList9.png
Models
Properties
Scripts
Views
Contact
Shared
Application.zip
NuGet.exe
NuGet.targets
Application.Common.csproj.user
Application.v11.suo
App_Data
Application.Web.csproj.user
glyphicons-halflings-white.png
glyphicons-halflings.png
ui-bg_flat_0_aaaaaa_40x100.png
ui-bg_flat_75_ffffff_40x100.png
ui-bg_glass_55_fbf9ee_1x400.png
ui-bg_glass_65_ffffff_1x400.png
ui-bg_glass_75_dadada_1x400.png
ui-bg_glass_75_e6e6e6_1x400.png
ui-bg_glass_95_fef1ec_1x400.png
ui-bg_highlight-soft_75_cccccc_1x100.png
ui-icons_222222_256x240.png
ui-icons_2e83ff_256x240.png
ui-icons_454545_256x240.png
ui-icons_888888_256x240.png
ui-icons_cd0a0a_256x240.png
ui-bg_flat_0_aaaaaa_40x100.png
ui-bg_flat_75_ffffff_40x100.png
ui-bg_glass_55_fbf9ee_1x400.png
ui-bg_glass_65_ffffff_1x400.png
ui-bg_glass_75_dadada_1x400.png
ui-bg_glass_75_e6e6e6_1x400.png
ui-bg_glass_95_fef1ec_1x400.png
ui-bg_highlight-soft_75_cccccc_1x100.png
ui-icons_222222_256x240.png
ui-icons_2e83ff_256x240.png
ui-icons_454545_256x240.png
ui-icons_888888_256x240.png
ui-icons_cd0a0a_256x240.png
favicon.ico
Global.asax
accent.png
bullet.png
heroAccent.png
orderedList0.png
orderedList1.png
orderedList2.png
orderedList3.png
orderedList4.png
orderedList5.png
orderedList6.png
orderedList7.png
orderedList8.png
orderedList9.png
Application_DB.zip
using Application.Common.Logging;
using Application.DTO;
using Application.Manager.Contract;
using Application.Manager.Resources;
using Application.Repository.ProfileModule;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Application.Manager.Conversion;
using Application.Core.ProfileModule.ProfileAggregate;
using Application.Common.Validator;
using Application.Common;
using Application.Core.ProfileModule.AddressAggregate;
using Application.Core.ProfileModule.PhoneAggregate;
using Application.Core.ProfileModule.ProfileAddressAggregate;
using Application.Core.ProfileModule.ProfilePhoneAggregate;
using Application.DTO.ProfileModule;

namespace Application.Manager.Implementation
{
    public class ContactManager : IContactManager
    {
        #region Global Declearation

        AddressRepository _addressRepository;
        AddressTypeRepository _addressTypeRepository;
        PhoneRepository _phoneRepository;
        PhoneTypeRepository _phoneTypeRepository;
        ProfileAddressRepository _profileAddressRepository;
        ProfilePhoneRepository _profilePhoneRepository;
        ProfileRepository _profileRepository;

        #endregion Global Declearation

        #region Constructor

        public ContactManager(AddressRepository addressRepository,
                              AddressTypeRepository addressTypeRepository,
                              PhoneRepository phoneRepository,
                              PhoneTypeRepository phoneTypeRepository,
                              ProfileAddressRepository profileAddressRepository,
                              ProfilePhoneRepository profilePhoneRepository,
                              ProfileRepository profileRepository)
        {
            if (addressRepository == null)
                throw new ArgumentNullException("addressRepository");

            if (addressTypeRepository == null)
                throw new ArgumentNullException("addressTypeRepository");

            if (phoneRepository == null)
                throw new ArgumentNullException("phoneRepository");

            if (phoneTypeRepository == null)
                throw new ArgumentNullException("phoneTypeRepository");

            if (profileAddressRepository == null)
                throw new ArgumentNullException("profileAddressRepository");

            if (profilePhoneRepository == null)
                throw new ArgumentNullException("profilePhoneRepository");

            if (profileRepository == null)
                throw new ArgumentNullException("profileRepository");

            _addressRepository = addressRepository;
            _addressTypeRepository = addressTypeRepository;
            _phoneRepository = phoneRepository;
            _phoneTypeRepository = phoneTypeRepository;
            _profileAddressRepository = profileAddressRepository;
            _profilePhoneRepository = profilePhoneRepository;
            _profileRepository = profileRepository;
        }

        #endregion Constructor

        #region Interface Implementation

        /// <summary>
        /// Get all Profiles
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageCount"></param>
        /// <returns></returns>
        public List<ProfileDTO> FindProfiles(int pageIndex, int pageCount)
        {
            if (pageIndex < 0 || pageCount <= 0)
                throw new ArgumentException(Messages.warning_InvalidArgumentForFindProfiles);

            //recover profiles in paged fashion
            var profiles = _profileRepository.GetPaged<DateTime>(pageIndex, pageCount, o => o.Created, false);
            var addressTypes = _addressTypeRepository.GetAll().ToList();
            var phoneTypes = _phoneTypeRepository.GetAll().ToList();

            if (profiles != null
                &&
                profiles.Any())
            {
                List<ProfileDTO> lstProfileDTO = new List<ProfileDTO>();
                foreach (var profile in profiles)
                {
                    lstProfileDTO.Add( Conversion.Mapping.ProfileToProfileDTO(profile, addressTypes, phoneTypes));
                }
                return lstProfileDTO;
            }
            else // no data
                return new List<ProfileDTO>();
        }

        /// <summary>
        /// Delete profile
        /// </summary>
        /// <param name="profileId"></param>
        public void DeleteProfile(int profileId)
        {
            var profile = _profileRepository.Get(profileId);

            if (profile != null) //if profile exist
            {
                //Delete all addresses associate with this profile 
                List<ProfileAddress> lstProfileAddress = profile.ProfileAddresses.ToList();
                foreach (ProfileAddress objProfileAddress in lstProfileAddress)
                {
                    this.DeleteProfileAddress(objProfileAddress);
                }

                //Delete all phones associate with this profile 
                List<ProfilePhone> lstProfilePhone = profile.ProfilePhones.ToList();
                foreach (ProfilePhone objProfilePhone in lstProfilePhone)
                {
                    this.DeleteProfilePhone(objProfilePhone);
                }

                _profileRepository.Remove(profile);

                //commit changes
                _profileRepository.UnitOfWork.Commit();
            }
            else //the customer not exist, cannot remove
                LoggerFactory.CreateLog().LogWarning(Messages.warning_CannotRemoveNonExistingProfile);
        }

        /// <summary>
        /// Find Profile by ID
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ProfileDTO FindProfileById(int id)
        {

            //recover orders
            var profile = _profileRepository.Get(id);
            var addressTypes = _addressTypeRepository.GetAll().ToList();
            var phoneTypes = _phoneTypeRepository.GetAll().ToList();

            if (profile != null)
            {
                return Conversion.Mapping.ProfileToProfileDTO(profile, addressTypes, phoneTypes);
            }
            else //no data
                return new ProfileDTO();

        }

        /// <summary>
        /// Get all initialization data for Contact page
        /// </summary>
        /// <returns></returns>
        public ContactForm InitializePageData()
        {
            var addressTypes = _addressTypeRepository.GetAll().ToList();
            var phoneTypes = _phoneTypeRepository.GetAll().ToList();

            ContactForm objContactForm = new ContactForm();
            objContactForm.lstAddressTypeDTO = Conversion.Mapping.AddressTypeToAddressTypeDTO(addressTypes);
            objContactForm.lstPhoneTypeDTO = Conversion.Mapping.PhoneTypeToPhoneTypeDTO(phoneTypes);

            return objContactForm;
        }

        /// <summary>
        /// Add new profile
        /// </summary>
        /// <param name="profileDTO"></param>
        /// <returns></returns>
        public void SaveProfileInformation(ProfileDTO profileDTO)
        {
            //if profileDTO data is not valid
            if (profileDTO == null)
                throw new ArgumentException(Messages.warning_CannotAddProfileWithNullInformation);

            //Create a new profile entity
            var newProfile = ProfileFactory.CreateProfile(profileDTO.FirstName, profileDTO.LastName, profileDTO.Email, "Anand", DateTime.Now, "Anand", DateTime.Now);

            //Save Profile
            newProfile = SaveProfile(newProfile);

            //if profileDTO contains any address
            if (profileDTO.AddressDTO != null)
            {
                foreach (AddressDTO objAddressDTO in profileDTO.AddressDTO)
                {
                    this.SaveAddress(objAddressDTO, newProfile);
                }
            }

            //if profileDTO contains any phone
            if (profileDTO.PhoneDTO != null)
            {
                foreach (PhoneDTO objPhoneDTO in profileDTO.PhoneDTO)
                {
                    this.SavePhone(objPhoneDTO, newProfile);
                }
            }
        }

        /// <summary>
        /// Update existing profile
        /// </summary>
        /// <param name="id"></param>
        /// <param name="profileDTO"></param>
        public void UpdateProfileInformation(int id, ProfileDTO profileDTO)
        {
            //if profileDTO data is not valid
            if (profileDTO == null)
                throw new ArgumentException(Messages.warning_CannotAddProfileWithNullInformation);

            //Create a new profile entity
            var currentProfile = _profileRepository.Get(id);

            //Assign updated value to existing profile
            var updatedProfile = new Profile();
            updatedProfile.ProfileId = id;
            updatedProfile.FirstName = profileDTO.FirstName;
            updatedProfile.LastName = profileDTO.LastName;
            updatedProfile.Email = profileDTO.Email;

            //Update Profile
            updatedProfile = this.UpdateProfile(currentProfile, updatedProfile);

            //Update Address
            List<AddressDTO> lstUpdatedAddressDTO = profileDTO.AddressDTO;
            List<ProfileAddress> lstCurrentAddress = _profileAddressRepository.GetFiltered(x => x.ProfileId.Equals(id)).ToList();

            UpdateAddress (lstUpdatedAddressDTO, lstCurrentAddress, updatedProfile);

            //Update Phone
            List<PhoneDTO> lstUpdatedPhoneDTO = profileDTO.PhoneDTO;
            List<ProfilePhone> lstCurrentPhone = _profilePhoneRepository.GetFiltered(x => x.ProfileId.Equals(id)).ToList();

            UpdatePhone(lstUpdatedPhoneDTO, lstCurrentPhone, updatedProfile);
        }

        #endregion Interface Implementation

        #region Private Methods

        /// <summary>
        /// Add new address
        /// </summary>
        /// <param name="addressDTO"></param>
        /// <param name="profile"></param>
        void SaveAddress(AddressDTO addressDTO, Profile profile)
        {
            //if addressDTO data is not valid
            if (addressDTO == null)
                throw new ArgumentException(Messages.warning_CannotAddProfileWithNullInformation);

            //Create a new Address entity
            var newAddress = AddressFactory.CreateAddress(addressDTO.AddressLine1, addressDTO.AddressLine2, addressDTO.City, addressDTO.State, addressDTO.Country,
                                                          addressDTO.ZipCode, "Anand", DateTime.Now, "Anand", DateTime.Now);
            //Save new Address
            SaveAddress(newAddress);

            var addressType = _addressTypeRepository.Get(addressDTO.AddressTypeId);

            //Create a new Profile Address entity
            var newProfileAddress = ProfileAddressFactory.ProfileAddress(profile, newAddress, addressType, "Anand", DateTime.Now, "Anand", DateTime.Now);

            //Save new Address
            SaveProfileAddress(newProfileAddress);
        }

        /// <summary>
        /// Save Address
        /// </summary>
        /// <param name="address"></param>
        Address SaveAddress(Address address)
        {
            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(address)) //if entity is valid save
            {
                //add address and commit changes
                _addressRepository.Add(address);
                _addressRepository.UnitOfWork.Commit();
                return address;
            }
            else //if not valid, throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(address));
        }

        /// <summary>
        /// Save Profile Address
        /// </summary>
        /// <param name="profileAddress"></param>
        void SaveProfileAddress(ProfileAddress profileAddress)
        {
            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(profileAddress))//if entity is valid save. 
            {
                //add profile address and commit changes
                _profileAddressRepository.Add(profileAddress);
                _profileAddressRepository.UnitOfWork.Commit();
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(profileAddress));
        }

        /// <summary>
        /// Update profile address
        /// </summary>
        /// <param name="lstUpdatedAddressDTO"></param>
        /// <param name="lstCurrentAddress"></param>
        void UpdateAddress (List<AddressDTO> lstUpdatedAddressDTO, List<ProfileAddress> lstCurrentAddress, Profile profile)
        {
            //if addressDTO data is not valid
            if (lstUpdatedAddressDTO == null && lstCurrentAddress == null) return;

            #region If user has deleted all existing address

            if (lstUpdatedAddressDTO == null && lstCurrentAddress != null)
            {
                foreach (ProfileAddress profileAddress in lstCurrentAddress)
                {
                    DeleteProfileAddress(profileAddress);
                }
                return;
            }

            #endregion If user has deleted all existing address

            #region If user has added new address and there was not any existing address

            if (lstUpdatedAddressDTO != null && lstCurrentAddress == null)
            {
                foreach (AddressDTO addressDTO in lstUpdatedAddressDTO)
                {
                    this.SaveAddress(addressDTO, profile);
                }
                return;
            }

            #endregion If user has added new address and there was not any existing address

            #region if user has updated or Deleted any record

            List<AddressDTO> lstNewAddress = lstUpdatedAddressDTO;

            //Check if address exist in database
            foreach (ProfileAddress profileAddress in lstCurrentAddress)
            {
                AddressDTO objAddressDTO = lstUpdatedAddressDTO.FirstOrDefault(x => x.AddressId.Equals(profileAddress.AddressId));

                if (objAddressDTO != null)
                {
                    Address updatedAddress = new Address();
                    updatedAddress.AddressId = objAddressDTO.AddressId;
                    updatedAddress.AddressLine1 = objAddressDTO.AddressLine1;
                    updatedAddress.AddressLine2 = objAddressDTO.AddressLine2;
                    updatedAddress.City = objAddressDTO.City;
                    updatedAddress.State = objAddressDTO.State;
                    updatedAddress.Country = objAddressDTO.Country;
                    updatedAddress.ZipCode = objAddressDTO.ZipCode;
                    UpdateAddress(profileAddress.Address, updatedAddress);
                    lstNewAddress.Remove(objAddressDTO);
                }
                else
                {
                    DeleteProfileAddress(profileAddress);
                }
            }

            //Save new address
            foreach (AddressDTO addressDTO in lstNewAddress)
            {
                this.SaveAddress(addressDTO, profile);
            }

            #endregion if user has updated or Deleted any record
        }

        /// <summary>
        /// Update existing Address
        /// </summary>
        /// <param name="profile"></param>
        void UpdateAddress(Address currentAddress, Address updatedAddress)
        {
            updatedAddress.Created = currentAddress.Created;
            updatedAddress.CreatedBy = currentAddress.CreatedBy;
            updatedAddress.Updated = DateTime.Now;
            updatedAddress.UpdatedBy = "Updated User";

            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(updatedAddress))//if entity is valid save. 
            {
                //add profile and commit changes
                _addressRepository.Merge(currentAddress, updatedAddress);
                _addressRepository.UnitOfWork.Commit();
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(updatedAddress));
        }

        /// <summary>
        /// Delete profile address
        /// </summary>
        /// <param name="profileId"></param>
        public void DeleteProfileAddress(ProfileAddress profileAddress)
        {
            var address = _addressRepository.Get(profileAddress.AddressId);

            if (address != null) //if address exist
            {
                _profileAddressRepository.Remove(profileAddress);
                //commit changes
                _profileAddressRepository.UnitOfWork.Commit();

                _addressRepository.Remove(address);
                //commit changes
                _addressRepository.UnitOfWork.Commit();
            }
            else //the customer not exist, cannot remove
                LoggerFactory.CreateLog().LogWarning(Messages.warning_CannotRemoveNonExistingProfile);
        }

        /// <summary>
        /// Add new phone
        /// </summary>
        /// <param name="phoneDTO"></param>
        /// <param name="profile"></param>
        void SavePhone(PhoneDTO phoneDTO, Profile profile)
        {
            //if phoneDTO data is not valid
            if (phoneDTO == null)
                throw new ArgumentException(Messages.warning_CannotAddProfileWithNullInformation);

            //Create a new Phone entity
            var newPhone = PhoneFactory.CreatePhone(phoneDTO.Number, "Anand", DateTime.Now, "Anand", DateTime.Now);

            //Save new Phone
            newPhone = SavePhone(newPhone);

            var phoneType = _phoneTypeRepository.Get(phoneDTO.PhoneTypeId);

            //Create a new Profile Phone entity
            var newProfilePhone = ProfilePhoneFactory.CreateProfilePhone(profile, newPhone, phoneType, "Anand", DateTime.Now, "Anand", DateTime.Now);

            //Save new Profile Phone
            SaveProfilePhone(newProfilePhone);
        }

        /// <summary>
        /// Save Phone
        /// </summary>
        /// <param name="phone"></param>
        Phone SavePhone(Phone phone)
        {
            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(phone)) //if entity is valid save
            {
                //add phone and commit changes
                _phoneRepository.Add(phone);
                _phoneRepository.UnitOfWork.Commit();
                return phone;
            }
            else //if not valid, throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(phone));
        }
    
        /// <summary>
        /// Save Profile Phone
        /// </summary>
        /// <param name="profilePhone"></param>
        void SaveProfilePhone(ProfilePhone profilePhone)
        {
            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(profilePhone))//if entity is valid save. 
            {
                //add profile phone and commit changes
                _profilePhoneRepository.Add(profilePhone);
                _profilePhoneRepository.UnitOfWork.Commit();
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(profilePhone));
        }

        /// <summary>
        /// Update profile phone
        /// </summary>
        /// <param name="lstUpdatedPhoneDTO"></param>
        /// <param name="lstCurrentPhone"></param>
        void UpdatePhone(List<PhoneDTO> lstUpdatedPhoneDTO, List<ProfilePhone> lstCurrentPhone, Profile profile)
        {
            //if addressDTO data is not valid
            if (lstUpdatedPhoneDTO == null && lstCurrentPhone == null) return;

            #region If user has deleted all existing Phone

            if (lstUpdatedPhoneDTO == null && lstCurrentPhone != null)
            {
                foreach (ProfilePhone profilePhone in lstCurrentPhone)
                {
                    DeleteProfilePhone(profilePhone);
                }
                return;
            }

            #endregion If user has deleted all existing Phone

            #region If user has added new Phone and there was not any existing Phone

            if (lstUpdatedPhoneDTO != null && lstCurrentPhone == null)
            {
                foreach (PhoneDTO phoneDTO in lstUpdatedPhoneDTO)
                {
                    this.SavePhone(phoneDTO, profile);
                }
                return;
            }

            #endregion If user has added new Phone and there was not any existing Phone

            #region if user has updated or Deleted any record

            List<PhoneDTO> lstNewPhone = lstUpdatedPhoneDTO;

            //Check if Phone exist in database
            foreach (ProfilePhone profilePhone in lstCurrentPhone)
            {
                PhoneDTO objPhoneDTO = lstUpdatedPhoneDTO.FirstOrDefault(x => x.PhoneId.Equals(profilePhone.PhoneId));

                if (objPhoneDTO != null)
                {
                    Phone updatedPhone = new Phone();
                    updatedPhone.PhoneId = objPhoneDTO.PhoneId;
                    updatedPhone.Number = objPhoneDTO.Number;
                    UpdatePhone(profilePhone.Phone, updatedPhone);
                    lstNewPhone.Remove(objPhoneDTO);
                }
                else
                {
                    DeleteProfilePhone(profilePhone);
                }
            }

            //Save new address
            foreach (PhoneDTO phoneDTO in lstNewPhone)
            {
                this.SavePhone(phoneDTO, profile);
            }

            #endregion if user has updated or Deleted any record
        }

        /// <summary>
        /// Update existing Phone
        /// </summary>
        /// <param name="currentPhone"></param>
        /// <param name="updatedPhone"></param>
        void UpdatePhone(Phone currentPhone, Phone updatedPhone)
        {

            updatedPhone.Created = currentPhone.Created;
            updatedPhone.CreatedBy = currentPhone.CreatedBy;
            updatedPhone.Updated = DateTime.Now;
            updatedPhone.UpdatedBy = "Updated User";

            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(updatedPhone))//if entity is valid save. 
            {
                //add profile and commit changes
                _phoneRepository.Merge(currentPhone, updatedPhone);
                _phoneRepository.UnitOfWork.Commit();
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(updatedPhone));
        }

        /// <summary>
        /// Delete profile phone
        /// </summary>
        /// <param name="profilePhone"></param>
        public void DeleteProfilePhone(ProfilePhone profilePhone)
        {
            var phone = _phoneRepository.Get(profilePhone.PhoneId);

            if (phone != null) //if phone exist
            {
                _profilePhoneRepository.Remove(profilePhone);
                //commit changes
                _profilePhoneRepository.UnitOfWork.Commit();

                _phoneRepository.Remove(phone);
                //commit changes
                _phoneRepository.UnitOfWork.Commit();
            }
            else //the customer not exist, cannot remove
                LoggerFactory.CreateLog().LogWarning(Messages.warning_CannotRemoveNonExistingProfile);
        }

        /// <summary>
        /// Save Profile
        /// </summary>
        /// <param name="profile"></param>
        Profile SaveProfile(Profile profile)
        {
            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(profile))//if entity is valid save. 
            {
                //add profile and commit changes
                _profileRepository.Add(profile);
                _profileRepository.UnitOfWork.Commit();
                return profile;
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(profile));
        }

        /// <summary>
        /// Update existing Profile
        /// </summary>
        /// <param name="profile"></param>
        Profile UpdateProfile(Profile currentProfile, Profile updatedProfile)
        {
            updatedProfile.Created = currentProfile.Created;
            updatedProfile.CreatedBy = currentProfile.CreatedBy;
            updatedProfile.Updated = DateTime.Now;
            updatedProfile.UpdatedBy = "Updated User";

            var entityValidator = EntityValidatorFactory.CreateValidator();

            if (entityValidator.IsValid(updatedProfile))//if entity is valid save. 
            {
                //add profile and commit changes
                _profileRepository.Merge(currentProfile, updatedProfile);
                _profileRepository.UnitOfWork.Commit();
                return updatedProfile;
            }
            else // if not valid throw validation errors
                throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(updatedProfile));
        }

        #endregion

    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Anand Ranjan Pandey
Software Developer (Senior)
United States United States
No Biography provided
Follow on   Twitter   Google+   LinkedIn

| Advertise | Privacy | Mobile
Web04 | 2.8.140926.1 | Last Updated 13 Jan 2013
Article Copyright 2013 by Anand Ranjan Pandey
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid