//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);
}