public async Task <IActionResult> Create([Bind("Name, CountryId")] CityVM city)
{
if (ModelState.IsValid)
{
try
{
await cityService.UpdateCityAsync(city.Adapt <CityDTO>());
}
catch (DbUpdateConcurrencyException)
{
if (!CityExists(city.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
var countries = await countryService.GetAllCountriesAsync();
ViewData["Countries"] = new SelectList(countries, "Id", "Name");
return(View(city));
}
public ActionResult Edit(int id)
{
var city = cityRepository.GetCityById(id);
if (city != null && city.Count > 0)
{
CityVM model = new CityVM();
model = city[0];
var countryList = new SelectList(countryRepository.GetCountries(), "Id", "Name").ToList();
ViewBag.CountryList = countryList;
//Get State
var stateList = new SelectList(new List <StateVM>(), "Id", "Name").ToList();
if (model.CountryId.HasValue)
{
stateList = new SelectList(stateRepository.GetStates(model.CountryId), "Id", "Name").ToList();
}
ViewBag.StateList = stateList;
return(View(model));
}
return(RedirectToAction("List"));
}
public IResponseDTO EditCity(CityVM model)
{
try
{
var DbCity = _mapper.Map <City>(model);
var entityEntry = _CityRepositroy.Update(DbCity);
int save = _unitOfWork.Commit();
if (save == 200)
{
_response.Data = model;
_response.IsPassed = true;
_response.Message = "Ok";
}
else
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Not saved";
}
}
catch (Exception ex)
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Error " + string.Format("{0} - {1} ", ex.Message, ex.InnerException != null ? ex.InnerException.FullMessage() : "");
}
return(_response);
}
public async Task <Response> RemoveCity(CityVM city)
{
try
{
var DTO = await _db.Cities.Where(x => x.Id == city.Id).FirstOrDefaultAsync();
_db.Cities.Remove(DTO);
int result = await _db.SaveChangesAsync();
if (result == 1)
{
// Mapper.Initialize(cfg => cfg.CreateMap<User, UserVM>());
return(GenericResponses <int> .ResponseStatus(false, Constant.MSGRecordFound, (int)Constant.httpStatus.Ok, result));
}
else
{
return(GenericResponses <int> .ResponseStatus(true, Constant.MSGFailed, (int)Constant.httpStatus.NoContent, result));
}
}
catch (Exception e)
{
return(GenericResponses <int> .ResponseStatus(true, e.Message, (int)Constant.httpStatus.NoContent, 0));
}
}
protected override async Task ExecuteAsync(object parameter)
{
if (_addressVM.CitySelected != null)
{
CityDialog dialog = new CityDialog();
List <Country> allCountries = await _countryRepository.GetAll().ConfigureAwait(true);
CityVM VM = new CityVM(_cityRepository, allCountries, CUD.Delete,
new Action(() => dialog.Close()), _user, _addressVM.CitySelected);
dialog.DataContext = VM;
bool?result = dialog.ShowDialog();
if (dialog.DialogResult.HasValue && dialog.DialogResult.Value)
{
_addressVM.AllCities = await _addressVM.GetAllCities().ConfigureAwait(true);
_addressVM.Cities.Clear();
foreach (City city in _addressVM.AllCities)
{
_addressVM.Cities.Add(city);
}
}
}
}
public void DeleteTest()
{
City v = new City();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v.Name = "Jmal";
context.Set <City>().Add(v);
context.SaveChanges();
}
PartialViewResult rv = (PartialViewResult)_controller.Delete(v.ID.ToString());
Assert.IsInstanceOfType(rv.Model, typeof(CityVM));
CityVM vm = rv.Model as CityVM;
v = new City();
v.ID = vm.Entity.ID;
vm.Entity = v;
_controller.Delete(v.ID.ToString(), null);
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
Assert.AreEqual(context.Set <City>().Count(), 0);
}
}
/// <summary>
/// Creates a City Model
/// </summary>
/// <param name="cityVM"></param>
/// <returns>City</returns>
public static City CreateDomainService(CityVM cityVM)
{
return(new City()
{
Name = cityVM.Name
});
}
public ActionResult Delete(string id)
{
CityVM cityVM = new CityVM();
cityVM.AllowDelete = true;
City city = new City();
city = cityRepository.GetCity(id);
//Check Exists
if (city == null)
{
ViewData["ActionMethod"] = "ViewGet";
return(View("RecordDoesNotExistError"));
}
cityVM.City = city;
//Attached Items
List <CityReference> supplierReferences = cityRepository.GetCityReferences(city.CityCode);
if (supplierReferences.Count > 0)
{
cityVM.AllowDelete = false;
cityVM.CityReferences = supplierReferences;
}
cityRepository.EditItemForDisplay(city);
return(View(cityVM));
}
public async Task <CityVM> PutAsync(CityVM City)
{
var newCityVM = iMapper.Map <CityVM, City>(City);
var newCity = await unitOfWork.CityRepository.AddOrUpdateAsync(newCityVM);
return(iMapper.Map <City, CityVM>(newCity));
}
public string UpdateCity(CityVM city)
{
string cityId = string.Empty;
SqlParameter[] parameters =
{
new SqlParameter {
ParameterName = "@Id", Value = city.Id
},
new SqlParameter {
ParameterName = "@CountryId", Value = city.CountryId
},
new SqlParameter {
ParameterName = "@StateId", Value = city.StateId
},
new SqlParameter {
ParameterName = "@Name", Value = city.Name
},
new SqlParameter {
ParameterName = "@IsActive", Value = city.IsActive
},
new SqlParameter {
ParameterName = "@UpdatedBy", Value = city.UpdatedBy
}
};
cityId = Convert.ToString(DALHelper.ExecuteScalar("UpdateCity", parameters));
return(cityId);
}
public async Task <JsonResult> RemoveCityy(CityVM city)
{
Response r = await Repository.RemoveCity(city);
// List<UserVM> employees = ((IEnumerable)r.Value).Cast<UserVM>().ToList(); ;
return(Json(r, JsonRequestBehavior.AllowGet));
}
public virtual ActionResult City(string urlName)
{
City city;
if (urlName == null)
{
var cityTC = UserSettingsService.CityTC;
if (cityTC == null || cityTC == Cities.Moscow)
{
return(Redirect(MainMenu.Urls.Locations));
}
city = CityService.GetByPK(cityTC);
}
else
{
city = CityService.GetAll().ByUrlName(urlName);
}
if (city == null)
{
return(Redirect(MainMenu.Urls.Locations));
}
var model =
new CityVM {
City = city,
Complexes = ComplexService.GetAll().ByCity(city.City_TC).ToList(),
Locations = SimplePageService.GetAll().BySysName(SimplePages.Locations),
Cities = CityService.GetAll()
.Where(c => c.City_TC != city.City_TC).ToList(),
Groups = GroupService.GetPlannedAndNotBegin().Where(x => x.WebinarExists).Take(20).ToList()
};
return(View(model));
}
public async Task <Response> AddCity(CityVM city)
{
var Dto = Mapper.Map <CityVM, City>(city);
City Exist = await _db.Cities.Where(x => x.City1.Trim() == city.City1.Trim()).FirstOrDefaultAsync();
if (Exist != null)
{
return(GenericResponses <int> .ResponseStatus(true, Constant.MDGNoAlreadyExist, (int)Constant.httpStatus.NoContent, 0));
}
_db.Cities.Add(Dto);
int result = await _db.SaveChangesAsync();
if (result == 1)
{
// Mapper.Initialize(cfg => cfg.CreateMap<User, UserVM>());
return(GenericResponses <int> .ResponseStatus(false, Constant.MSGRecordFound, (int)Constant.httpStatus.Ok, result));
}
else
{
return(GenericResponses <int> .ResponseStatus(true, Constant.MDGNoLoginFailed, (int)Constant.httpStatus.NoContent, result));
}
}
public async Task <IActionResult> Upsert(CityVM cityVM)
{
if (ModelState.IsValid)
{
if (cityVM.City.Id == 0)
{
_unitOfWork.CityRepository.Add(cityVM.City);
}
else
{
_unitOfWork.CityRepository.Update(cityVM.City);
}
_unitOfWork.Save();
return(RedirectToAction(nameof(Index)));
}
else
{
cityVM.CountryList = _unitOfWork.CountryRepository.GetAll().Select(i => new SelectListItem
{
Text = i.Name,
Value = i.Id.ToString()
});
if (cityVM.City.Id != 0)
{
cityVM.City = _unitOfWork.CityRepository.Get(cityVM.City.Id);
}
}
return(View(cityVM));
}
public ActionResult Select()
{
string mode = Request.QueryString["Grid-mode"];
if (!string.IsNullOrEmpty(mode))
{
return(this.RedirectToAction("Create"));
}
else
{
List <CityVM> viewModels = new List <CityVM>();
CityBAL balObject = new CityBAL();
IQueryable <Entities.City> entites = balObject.GetAll();
foreach (Entities.City entity in entites)
{
CityVM viewModel = new CityVM();
viewModel.CityId = entity.CityId;
viewModel.CityName = entity.CityName;
viewModel.DistrictName = entity.DistrictName;
viewModel.Status = entity.Status;
viewModel.Remark = entity.Remark;
viewModels.Add(viewModel);
}
return(View(new GridModel <CityVM> {
Data = viewModels
}));
}
}
public IActionResult Upsert(int?id)
{
CityVM cityVM = new CityVM()
{
City = new City(),
CountryList = _unitOfWork.CountryRepository.GetAll().Select(i => new SelectListItem
{
Text = i.Name,
Value = i.Id.ToString()
})
};
if (id == null)
{
//this is for create
return(View(cityVM));
}
//this is for edit
cityVM.City = _unitOfWork.CityRepository.Get(id.GetValueOrDefault());
if (cityVM.City == null)
{
return(NotFound());
}
return(View(cityVM));
}
public IResponseDTO DeleteCity(CityVM model)
{
try
{
var DbCity = _mapper.Map <City>(model);
var entityEntry = _CityRepositroy.Remove(DbCity);
int save = _unitOfWork.Commit();
if (save == 200)
{
_response.Data = null;
_response.IsPassed = true;
_response.Message = "Ok";
}
else
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Not saved";
}
}
catch (Exception ex)
{
_response.Data = null;
_response.IsPassed = false;
_response.Message = "Error " + ex.Message;
}
return(_response);
}
public void EditTest()
{
City v = new City();
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
v.Name = "Jmal";
context.Set <City>().Add(v);
context.SaveChanges();
}
PartialViewResult rv = (PartialViewResult)_controller.Edit(v.ID.ToString());
Assert.IsInstanceOfType(rv.Model, typeof(CityVM));
CityVM vm = rv.Model as CityVM;
v = new City();
v.ID = vm.Entity.ID;
v.Name = "Twnl7";
vm.Entity = v;
vm.FC = new Dictionary <string, object>();
vm.FC.Add("Entity.Name", "");
_controller.Edit(vm);
using (var context = new DataContext(_seed, DBTypeEnum.Memory))
{
var data = context.Set <City>().FirstOrDefault();
Assert.AreEqual(data.Name, "Twnl7");
}
}
public List <string> GetBreadCrumbs(CityVM model)
{
var breadcrumb = new List <string>();
breadcrumb.Add(HtmlControls.Anchor(MainMenu.Urls.Locations,
"Классы и филиалы").ToString());
return(breadcrumb);
}
private static Grad convertViewModelToEntity(CityVM viewModel)
{
return(new Grad
{
IDGrad = viewModel.IDCity,
Naziv = Utils.GetCleanTitleString(viewModel.Name),
DrzavaID = viewModel.CountryID
});
}
public IActionResult CreateCity(int countryId)
{
var vm = new CityVM
{
CountryId = countryId
};
return(View(vm));
}
public async Task <JsonResult> AddCity(CityVM city)
{
city.EcomID = (int)Session["Comp"];
city.CreatedOn = DateTime.Today;
Response r = await Repository.AddCity(city);
// List<UserVM> employees = ((IEnumerable)r.Value).Cast<UserVM>().ToList(); ;
return(Json(r, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(int?id)
{
CityVM city = new CityVM();
if (id != null)
{
city = WebApiClient.Build().Get <CityVM>(EndPoints.Cities, id);
}
return(View(city));
}
public ActionResult Add(CityVM cityVM)
{
City city = Mapper.Map <City>(cityVM);
if (_cityManager.Add(city))
{
TempData["saved"] = "Saved Successfully";
return(RedirectToAction("Add"));
}
return(RedirectToAction("Add"));
}
public ActionResult Update(CityVM cityVM)
{
City city = Mapper.Map <City>(cityVM);
if (_cityManager.Update(city))
{
TempData["updated"] = "Updated sauccessfully!";
return(RedirectToAction("Add"));
}
return(View());
}
public ActionResult Add()
{
if ((string)Session["user"] != "admin")
{
return(RedirectToAction("../Home/Login"));
}
CityVM cityVM = new CityVM();
cityVM.Cities = _cityManager.GetAll();
cityVM.CountryLookup = _countryManager.Lookup();
return(View(cityVM));
}
// TODO: Protect City/Detail with AuthorizeFilter so the user must be logged in (any role)
public IActionResult Detail(int id)
{
CityVM vm = new CityVM(GetCurrentUser());
vm.City = cityDAO.GetCityById(id);
if (vm.City == null)
{
return(NotFound());
}
return(View(vm));
}
/* public static void ComplexMap(this ViewPage<Complex> viewPage)
* {
* var filename = "~/Content/Center/Map/" +
* viewPage.Model.Complex_ID +".html";
* if(File.Exists(viewPage.Server.MapPath(filename)))
* viewPage.Response.WriteFile(filename);
* }*/
public static SubSectionsWithNoteVM GetComplexes(this CityVM cityVM)
{
var complexes = cityVM.Complexes.Select(c =>
new SubSectionWithNote(c, c.Address.Tag("p")))
.ToList();
return(new SubSectionsWithNoteVM {
List = complexes,
Title = "Комплексы",
SmallImage = true
});
}
//
// GET: /SysAdmin/City/Create
public ActionResult Create()
{
CityVM viewModel = new CityVM();
DistrictBAL districtBAL = new DistrictBAL();
viewModel.Districts = from obj in districtBAL.GetAll() select new SelectListItem()
{
Text = obj.DistrictName, Value = obj.DistrictId.ToString()
};
viewModel.Status = true;
return(View(viewModel));
}
public ActionResult Update(int id)
{
if ((string)Session["user"] != "admin")
{
return(RedirectToAction("../Home/Login"));
}
var city = _cityManager.GetById(id);
CityVM cityVM = Mapper.Map <CityVM>(city);
cityVM.CountryLookup = _countryManager.Lookup();
return(View(cityVM));
}
