public IActionResult CinemaCreate(string Address, string city, string CinemaName)
{
var CinemaLocation = new CinemaLocation()
{
Address = Address,
CinemaHalls = new List <CinemaHall>(),
CinemaName = CinemaName,
FoodAmounts = new List <FoodAmount>()
};
var City = cityService.Get().Find(a => a.CityName == city);
if (City != null)
{
CinemaLocation.CityId = City.Id;
CinemaLocation.City = City;
}
else
{
City = cityService.Add(new City()
{
CityName = city
});
CinemaLocation.CityId = City.Id;
CinemaLocation.City = City;
}
cinemaLocationService.Add(CinemaLocation);
return(RedirectToAction("CinemaLocationTable"));
}
[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));
}
}
public IActionResult Create([FromForm] CityCreateModel entity)
{
if (ModelState.IsValid)
{
string currentUser = HttpContext?.User?.Identity?.Name;
if (!String.IsNullOrEmpty(currentUser))
{
try
{
AuditedEntityMapper <CityCreateModel> .FillCreateAuditedEntityFields(entity, currentUser, CountryId);
bool statusResult = _cityService.Add(entity);
if (statusResult)
{
return(RedirectToAction(nameof(Index)).WithSuccess(LOCALIZATION_SUCCESS_DEFAULT));
}
else
{
return(RedirectToAction(nameof(Index)).WithError(LOCALIZATION_ERROR_DEFAULT));
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(RedirectToAction(nameof(Index)).WithError(ex.Message));
}
}
else
{
_logger.LogError(LOCALIZATION_ERROR_USER_MUST_LOGIN);
return(NotFound().WithError(LOCALIZATION_ERROR_USER_MUST_LOGIN));
}
}
return(View(entity).WithWarning(LOCALIZATION_WARNING_INVALID_MODELSTATE));
}
public IActionResult Create(CityModel city)
{
Result <List <CountryModel> > countriesResult;
if (ModelState.IsValid)
{
var result = _cityService.Add(city);
if (result.Status == ResultStatus.Success)
{
return(RedirectToAction(nameof(Index)));
}
if (result.Status == ResultStatus.Error)
{
ModelState.AddModelError("", result.Message);
countriesResult = _countryService.GetCountries();
if (countriesResult.Status == ResultStatus.Exception)
{
throw new Exception(countriesResult.Message);
}
ViewBag.Countries = new SelectList(countriesResult.Data, "Id", "Name", city.CountryId);
return(View(city));
}
throw new Exception(result.Message);
}
countriesResult = _countryService.GetCountries();
if (countriesResult.Status == ResultStatus.Exception)
{
throw new Exception(countriesResult.Message);
}
ViewBag.Countries = new SelectList(countriesResult.Data, "Id", "Name", city.CountryId);
return(View(city));
}
public void AddTest()
{
var count = _memoryDbContext.Cities.Count();
var cityCreateModel = Builder <CityCreateModel> .CreateNew().Build();
Assert.IsTrue(_cityService.Add(cityCreateModel));
Assert.IsTrue(_memoryDbContext.Cities.Count() == count + 1);
}
public IActionResult Create(CreateCity createCity)
{
if (ModelState.IsValid)
{
_cityService.Add(createCity);
return(RedirectToAction(nameof(Index)));
}
return(View(createCity));
}
public IActionResult Add(City city)
{
var result = _cityService.Add(city);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult Add([FromBody] City city)
{
var result = _cityService.Add(city);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest());
}
public async Task <IActionResult> AddCity([FromBody] CityDTO city)
{
if (ModelState.IsValid)
{
city = await _cityService.Add(city);
return(Ok(city));
}
return(BadRequest(ModelState));
}
public ActionResult Create(CreateCity createCity)
{
if (ModelState.IsValid)
{
_cityService.Add(createCity);
return(RedirectToAction(nameof(Index)));
}
createCity.Countries = _countryService.All().CountryList;
return(View(createCity));
}
public virtual ActionResult Create(CityEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var id = _cities.Add(model);
return(RedirectToAction(MVC.City.Edit(id)));
}
public async Task <IActionResult> Add(City city)
{
var result = await _cityService.Add(city);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
// POST: CityController/Create
public IActionResult Create(CreateCity createCity) // This is the second to be called
{
if (ModelState.IsValid)
{
_cityService.Add(createCity);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(createCity)); // If it fails send it back to ActionResult Create
}
}
public ActionResult Create(CreateCityViewModel createcitys)
{
if (ModelState.IsValid)
{
_cityService.Add(createcitys);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(createcitys));
}
}
public ActionResult Create(City city)
{
if (city != null)
{
if (!string.IsNullOrEmpty(city.cityName) || !string.IsNullOrWhiteSpace(city.cityName))
{
_cityService.Add(city);
_logger.LogInformation("New City was added!");
}
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Add(string city)
{
if (city == null)
{
throw new ArgumentNullException(nameof(city));
}
_cityService.Add(new City()
{
Name = city
});
return(Json(true));
}
public IActionResult Create([FromBody] CityCreateDTO cityDto)
{
try
{
var city = _mapper.Map <City>(cityDto);
_cityService.Add(city);
return(Ok("City successfully created."));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public ActionResult Create(CityViewModel city)
{
if (!ModelState.IsValid)
{
ErrorNotification("Kayıt Eklenemedi!");
return(RedirectToAction("Create"));
}
_cityService.Add(new City
{
CityName = city.CityName
});
SuccessNotification("Kayıt Eklendi.");
return(RedirectToAction("CityIndex"));
}
public ActionResult Add(string Name, int countryId)
{
if (string.IsNullOrEmpty(Name))
{
return(Content("error, invalid Name!"));
}
City city = new City()
{
Name = Name,
CountryId = countryId
};
CityService.Add(city);
return(Content("ok"));
}
public ActionResult Create(CityViewModel city)
{
if (!ModelState.IsValid)
{
ErrorNotification("Kayıt Eklenemedi!");
return(RedirectToAction("Create"));
}
_cityService.Add(new City
{
//TODO:Alanlar buraya yazılacak
//Örn:BrandName = brand.BrandName,
});
SuccessNotification("Kayıt Eklendi.");
return(RedirectToAction("CityIndex"));
}
public ActionResult Create(CityViewModel cityModel)
{
if (!ModelState.IsValid)
{
return(View());
}
CityMaster cityMasterModel = new CityMaster();
cityMasterModel.CityName = cityModel.CityName;
cityMasterModel.CityShortName = cityModel.CityShortName;
cityMasterModel.IsActive = true;
_cityMasterService.Add(cityMasterModel);
_cityMasterService.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Add(CityModel city)
{
if (ModelState.IsValid)
{
var cityDTO = _cityMaper.MapBack(city);
_cityService.Add(cityDTO);
return(RedirectToAction("List"));
}
else
{
List <CountryDTO> countryDTOList = _countryService.GetAll();
var countryList = _countryMaper.Map(countryDTOList);
ViewBag.CountryList = countryList;
return(View());
}
}
public async Task <IActionResult> Add([FromBody] CityDTO model)
{
if (!ModelState.IsValid)
{
return(new ValidationFailedResult(ModelState));
}
try
{
var data = await _service.Add(model);
return(Ok(data));
}
catch (Exception e)
{
ModelState.AddModelError("PopUpError", e.Message);
return(new ValidationFailedResult(ModelState));
}
}
public IActionResult PostCity([FromBody] CreateEditCityViewModel model, int provinceID)
{
DataClaim.GetClaim(Request);
var city = new City();
model.ProvinceID = provinceID.ToString();
if (model is null)
{
return(BadRequest("City is null."));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
_mapper.Map(model, city);
_cityProvider.Add(city);
return(Ok(city));
}
public ActionResult Create(CreateCityViewModel createCity)
{
City city = null;
if (ModelState.IsValid)
{
city = _cityService.Add(createCity);
if (city == null)
{
ModelState.AddModelError("msg", "Database Problem");
return(View(createCity));
}
return(RedirectToAction(nameof(City)));
}
else
{
return(View(createCity));
}
}
public ActionResult Add(Models.City.AddViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
HealthyDuty.Data.Entity.City city = new HealthyDuty.Data.Entity.City();
city.Code = model.Code;
city.Name = model.Name;
try
{
_cityService.Add(city);
return(RedirectToAction(nameof(CityController.List)));
}
catch
{
ViewBag.ErrorMessage = "Not Saved.";
return(View(model));
}
}
public IActionResult Post([FromBody] City city)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new Response
{
Status = "Error",
Messages = new Message[] {
new Message {
Lang_id = 1,
MessageLang = "Model state isn't valid!"
},
new Message {
Lang_id = 2,
MessageLang = "Состояние модели недействительно!"
},
new Message {
Lang_id = 3,
MessageLang = "Model vəziyyəti etibarsızdır!"
}
}
}));
}
_cityContext.Add(city);
foreach (CityNameTranslate item in city.CityNameTranslates)
{
item.CityId = city.Id;
_cityTranslateContext.Add(item);
}
return(Ok());
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
// [ResponseCodes(HttpStatusCode.OK, HttpStatusCode.NotAcceptable, HttpStatusCode.Unauthorized)]
public int AddCity([FromBody] InputCityDto dto)
{
return(_iCityService.Add(CurrentLanguage, dto));
}
public async Task Consume(ConsumeContext <IAddCity> context)
{
await Task.Run(() => _service.Add(context.Message.Id, context.Message.Name));
}
public async Task <IActionResult> Add([FromBody] CityAddModel model)
{
return(await MakeActionCallAsync(async() => await _cityService.Add(model)));
}
