public CityUpdateModel(City city)
 {
     CountryCode = city.CountyCode;
     StateId = city.StateId;
     CityName = city.CityName;
     NickName = city.NickName;
 }
        public City Update(City entity)
        {
            var errors = ValidateCityUpdate(entity);
            if (!errors.Any())
            {
                entity = CityRepository.Update(entity);
                return entity;
            }

            throw new ErrorException(errors);
        }
 public void Delete(City entity)
 {
     try
     {
         CityRepository.Delete(entity);
     }
     catch (Exception ex)
     {
         throw new ErrorException(new[] { new Error(string.Empty, ex.Message) });
     }
 }
        public ActionResult Create(CityCreateModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var country = CountriesService.GetCountryByCountryCode(model.CountryCode);
                    var state = StatesService.GetStateByStateId(model.StateId);
                    if (country != null && state != null)
                    {
                        var city = new City()
                        {
                            CityName = model.CityName,
                            CountyCode = country.CountryCode,
                            NickName = model.NickName,
                            StateId = model.StateId,
                            State = state
                        };

                        city = CitiesService.Create(city);
                        this.FlashInfo(string.Format("City {0} was created successfully", city.CityName));
                        return RedirectToAction("Index");
                    }
                }
                catch (ErrorException errorException)
                {
                    errorException.ToModelState(this);
                    return View(model);
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("", ex.Message);
                    return View(model);
                }
            }
            return View(model);
        }
 public CityDeleteModel(City city)
 {
     City = city;
 }
        IEnumerable<Error> BasicCityValidation(City entity)
        {
            if (entity.State == null)
                yield return new Error("State");

            if (string.IsNullOrEmpty(entity.CityName))
                yield return new Error("CityName", "City Name is required.");

            if (string.IsNullOrEmpty(entity.CityName))
                yield return new Error("CityName", "City Name is required.");
        }
 IEnumerable<Error> ValidateUniquenessOfCityName(City entity)
 {
     if (entity.State.Cities.Any(c => c.CityName.Equals(entity.CityName, StringComparison.InvariantCultureIgnoreCase)))
         yield return new Error("CityName", string.Format("The city name {0} is already used. Please try another", entity.CityName));
 }
        IEnumerable<Error> ValidateCityUpdate(City entity)
        {
            foreach (var error in BasicCityValidation(entity)) yield return error;

            var oldCity = GetCityByCityId(entity.CityId);
            if (!oldCity.CityName.Equals(entity.CityName, StringComparison.InvariantCultureIgnoreCase))
                foreach (var error in ValidateUniquenessOfCityName(entity)) yield return error;
        }
        IEnumerable<Error> ValidateCityCreate(City entity)
        {
            foreach (var error in BasicCityValidation(entity)) yield return error;

            foreach (var error in ValidateUniquenessOfCityName(entity)) yield return error;
        }