//Read information about the address and creates it: /// <summary> /// Read information about the address and creates it: /// </summary> /// <param name="addressName"></param> /// <param name="cityViewModel"></param> /// <returns></returns> public int CreateAddress(string addressName, CreateCityViewModel cityViewModel) { var cityId = default(int); if (IsCityNotExist(cityViewModel)) { cityId = this.citiesService.CreateCity(cityViewModel.CityName, cityViewModel.CountryCode); } else { cityId = this.citiesService.GetCityIdByName(cityViewModel.CityName); } var city = context.Cities.FirstOrDefault(x => x.Id == cityId); var address = new Address() { AddressName = addressName, CityId = cityId, City = city }; this.context.Addresses.Add(address); this.context.SaveChanges(); return(address.Id); }
public async Task <JsonResult> Addcity(CreateCityViewModel ccvm) { var data = "City Added Failed !"; var status = false; try { var firebase = FirebaseConnection.FirebaseDatabase(); var cityList = await firebase.Child("city").Child(ccvm.state).OnceAsync <GetCityViewModel>(); foreach (var cityDetail in cityList) { if (cityDetail.Object.cityName.Equals(ccvm.cityName, StringComparison.CurrentCultureIgnoreCase)) { data = "City Name Already Exist !"; return(Json(new { data = data, status = status }, JsonRequestBehavior.AllowGet)); } } ccvm.cityName = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(ccvm.cityName.ToLower().Trim()); var cityAdded = await firebase.Child("city").Child(ccvm.state).PostAsync(ccvm, true); data = "City Added Successfully !"; status = true; } catch (Exception cityAddException) { var cityError = cityAddException.GetType().GetProperty("Reason").GetValue(cityAddException, null); } return(Json(new { data = data, status = status }, JsonRequestBehavior.AllowGet)); }
// GET: CityController/City public ActionResult City() { CreateCityViewModel ctyVM = new CreateCityViewModel(); ctyVM.CityList = _cityService.All(); return(View(ctyVM)); }
public async Task <IActionResult> AddCity(int?id) { var model = new CreateCityViewModel(); if (id != null) { var city = await _placeService.GetCityByIdAsync(id.Value); if (city == null) { throw new AwroNoreException("City Not Found"); } model = new CreateCityViewModel { Id = city.Id, Name = city.Name, Name_Ar = city.Name_Ar, Name_Ku = city.Name_Ku, ProvinceId = city.ProvinceId }; } model.listProvinces = _commonUtils.PopulateProvincesList(); return(PartialView(model)); }
[ValidateAntiForgeryToken] //What is antiforgerytoken? "special safety for intruders" public ActionResult Create(CreateCityViewModel createCity) { Country country = _countryService.FindBy(createCity.Country.Id); //person.Name = createPerson.Name; //person.PhoneNumber = createPerson.PhoneNumber; createCity.Country = country; if (ModelState.IsValid) { City city = _cityService.Add(createCity); if (city == null) { ModelState.AddModelError("msg", "Database problems"); return(View(createCity)); } return(RedirectToAction(nameof(Index))); } else { return(View(createCity)); } }
// GET: CityController/Create public ActionResult Create() { CreateCityViewModel createVM = new CreateCityViewModel(); createVM.Countries = _countryService.All().Countries; return(View(createVM)); }
// GET: PeopleController/Create public ActionResult Create() { CreateCityViewModel createCityViewModel = new CreateCityViewModel(); createCityViewModel.Countries = _countryService.All().countrieList; return(View(createCityViewModel)); }
public void AddressCreateMethodValidationIsWorking() { CreateCityViewModel someViewModel = null; Assert.Throws <InvalidProxyConstructorArgumentsException> (() => fakeAddressService.Object.CreateAddress(null, someViewModel), "Address was not created properly, because of problems in method logic!"); }
public async Task <IActionResult> Create() { var vm = new CreateCityViewModel(); vm.AllCountries = await countryRepository.GetCountriesAsync(); return(View(vm)); }
// GET: CityController/Create public ActionResult Create() { PeopleViewModel pplVM = _peopleService.All(); CreateCityViewModel cityVM = new CreateCityViewModel(); cityVM.PersonInCity = pplVM.AllPeople; return(View(cityVM)); }
public City Edit(int id, CreateCityViewModel edit) { City editedCity = new City() { Id = id, PersonInCity = edit.PersonInCity, States = edit.States, CityName = edit.CityName }; return(_cityRepo.Update(editedCity)); }
public ActionResult Create() { CreateCityViewModel createCityViewModel = new CreateCityViewModel(); createCityViewModel.CountryList = _countryService.All(); //Why sending in cCVM with all? (So they can be displayed in dropdown) return(View(createCityViewModel)); }
public async Task <IActionResult> Post([FromBody] CreateCityViewModel viewModel) { var command = _mapper.Map <CreateCityCommand>(viewModel); var result = await _mediator.Send(command, CancellationToken.None); var output = _mapper.Map <CityViewModel>(result.Data); return(Response(result, output)); }
public async Task <IActionResult> Create(CreateCityViewModel createCityViewModel) { if (ModelState.IsValid) { await cityRepository.CreateCityAsync(createCityViewModel.City); } return(RedirectToAction(nameof(Index))); }
public async Task <IActionResult> CreateCity() { var model = new CreateCityViewModel { Countries = _mapper.Map <List <CountryViewModel> >(await _nomenclatureService.GetCountries()) }; return(View(model)); }
public ActionResult CityDetails(int id) { CreateCityViewModel ctyVm = new CreateCityViewModel(); City cityDetails = _cityService.FindBy(id); ctyVm.CityName = cityDetails.CityName; ctyVm.States = cityDetails.States; ctyVm.PersonInCity = _cityService.FindAllPerson(id); return(View(ctyVm)); }
public async Task <IActionResult> Edit(int cityId) { var vm = new CreateCityViewModel(); vm.City = await cityRepository.GetCityDetailsAsync(cityId); vm.AllCountries = await countryRepository.GetCountriesAsync(); return(View(vm)); }
public City Add(CreateCityViewModel createCity) { City city = new City(); city.CityName = createCity.cityName; city.CountryNationsName = _countryRepo.Read(createCity.NationsId); city = _cityRepo.Create(city); return(city); }
public City Edit(int id, CreateCityViewModel city) { City editCity = new City() { Id = id, Name = city.Name, }; return(_citysRepo.Update(editCity)); throw new NotImplementedException(); }
public ActionResult Edit(City city) { CreateCityViewModel createCity = new CreateCityViewModel(); createCity.Name = city.Name; createCity.Country = city.Countries; City editCity = _citysService.Edit(city.Id, createCity); return(RedirectToAction(nameof(Index))); }
public ActionResult Create(CreateCityViewModel createcitys) { if (ModelState.IsValid) { _cityService.Add(createcitys); return(RedirectToAction(nameof(Index))); } else { return(View(createcitys)); } }
public ActionResult Create(CreateCityViewModel createCityViewModel) { if (ModelState.IsValid) { createCityViewModel.Country = _countryService.FindBy(createCityViewModel.Country.Id); if (createCityViewModel.Country != null) { _citysService.Add(createCityViewModel); return(RedirectToAction(nameof(Index))); } } return(View(createCityViewModel)); }
public ActionResult Edit(int id) { PeopleViewModel pplVM = _peopleService.All(); CreateCityViewModel cityVM = new CreateCityViewModel(); City editCity = _cityService.FindBy(id); cityVM.States = editCity.States; cityVM.CityName = editCity.CityName; cityVM.PersonInCity = pplVM.AllPeople; cityVM.updateCityID = id; return(View("Edit", cityVM)); }
public async Task <IActionResult> CreateCity(CreateCityViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var createModel = _mapper.Map <CityServiceModel>(model); createModel.Country = await _nomenclatureService.GetCountry(model.CountryId); await _adminService.CreateCity(createModel); return(RedirectToAction(nameof(Cities))); }
public City Add(CreateCityViewModel createCityViewModel) { List <Person> personInCity = new List <Person>(); foreach (int personID in createCityViewModel.PeopleID) { Person person = _peopleRepo.Read(personID); personInCity.Add(person); } City city = _cityRepo.Create(personInCity, createCityViewModel.States, createCityViewModel.CityName); return(city); }
public async Task <IActionResult> CreateCity(CreateCityViewModel vm) { if (ModelState.IsValid) { await db.Cities.AddAsync(new City() { Name = vm.Name }); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(vm)); }
public async Task <int> CreateCityAsync(CreateCityViewModel model, int countryId) { var city = new City { Name = model.CityName, PostCode = model.PostCode, CreatedOn = DateTime.UtcNow, IsDeleted = false, CountryId = countryId }; await this.cityRepository.AddAsync(city); await this.cityRepository.SaveChangesAsync(); return(city.Id); }
public City Add(CreateCityViewModel createCity) { //create city City city = new City(); city.Name = createCity.Name; city.Nation = _countryRepo.Read(createCity.NationId); city = _cityRepo.Create(city); //update Country with city --should not be needed //Country countryToUpdate = _countryRepo.Read(city.Nation.Id); //if (countryToUpdate != null) //{ // _countryRepo.Read(createCity.NationId).Cities.Add(city); //} return(city); }
// GET: CityController/Edit/5 public ActionResult Edit(int id) { City city = _cityService.FindBy(id); if (city != null) { CreateCityViewModel createModel = new CreateCityViewModel(); createModel.Name = city.Name; createModel.NationId = city.Nation.Id; createModel.Countries = _countryService.All().Countries; EditCityViewModel editCityVM = new EditCityViewModel(); editCityVM.Id = id; editCityVM.CreateVM = createModel; return(View(editCityVM)); } return(RedirectToAction(nameof(Index))); }
public async Task <int> PrepareCityAndCountry(CreateCityViewModel cityModel, string countryName) { var countryId = this.countryService.CheckCountryExist(countryName); if (countryId == 0) { countryId = await this.countryService.CreateCountryAsync(countryName); } var cityId = this.cityService.CheckIfCityExist(cityModel.CityName, countryId); if (cityId == 0) { cityId = await this.cityService.CreateCityAsync(cityModel, countryId); } return(cityId); }