public HttpResponseMessage Post(GenreAddUpdateViewModel genreAddUpdateViewModel)
{
GenreLocalizationViewModel englishLocalization = GetLocalization(genreAddUpdateViewModel, "en");
if (IsLocalizationEmpty(englishLocalization))
{
ModelState.AddModelError("LocalizationError", "English localization should exist. ");
}
else
{
CheckAndFixLocalizations(genreAddUpdateViewModel);
}
if (ModelState.IsValid)
{
CleanEmptyLocalizations(genreAddUpdateViewModel);
var genreModel = Mapper.Map <GenreModel>(genreAddUpdateViewModel);
_genreService.Add(genreModel);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
public IActionResult Create(Genre genre)
{
if (ModelState.IsValid)
{
_genreService.Add(genre);
return(RedirectToAction(nameof(Index)));
}
else
{
_logger.LogInformation(LoggerMessageDisplay.GenreNotCreatedModelStateInvalid);
}
return(View());
}
public async Task <ActionResult <GenreDto> > PostGenre([FromBody] GenreDto genreDto)
{
_logger.LogInformation("Post genre {GenreDto}", genreDto);
var insertedGenre = await _genreService.Add(genreDto);
return(CreatedAtAction("GetGenre", new { id = insertedGenre.Id }, insertedGenre));
}
public async Task <IHttpActionResult> Add(GenreModel model)
{
var serviceResult = new ServiceResult <GenreModel>();
ModelState.Remove("model.Id");
if (!ModelState.IsValid)
{
serviceResult.Success = false;
serviceResult.Error.Description = "Model is not valid.";
serviceResult.Error.Code = ErrorStatusCode.BudRequest;
return(ServiceResult(serviceResult));
}
model.Id = System.Guid.NewGuid().ToString("N").Substring(0, 24);
var result = await _genreService.Add(model);
serviceResult.Success = result.Success;
if (result.Success)
{
serviceResult.Result = model;
}
else
{
serviceResult.Error = result.Error;
}
return(ServiceResult(serviceResult));
}
public IActionResult Add(AddGenreViewModel model)
{
if (ModelState.IsValid)
{
try
{
_genreService.Add(new GenreDTO()
{
Name = model.Name
});
_loggerService.LogInformation(CONTROLLER_NAME + LoggerConstants.ACTION_ADD, LoggerConstants.TYPE_POST, $"add genre name: {model.Name} successful", GetCurrentUserId());
return(RedirectToAction("Index"));
}
catch (ValidationException ex)
{
_loggerService.LogWarning(CONTROLLER_NAME + LoggerConstants.ACTION_ADD, LoggerConstants.TYPE_POST, $"add genre name: {model.Name} error: {ex.Message}", GetCurrentUserId());
ModelState.AddModelError(ex.Property, ex.Message);
}
}
return(View(model));
}
public ActionResult Save(GenreView model)
{
if (!ModelState.IsValid)
{
return(View("Edit", model));
}
try
{
if (model.Id == 0)
{
_genreService.Add(model);
}
else
{
_genreService.Update(model);
}
}
catch (ItemAlreadyExistException)
{
ModelState.AddModelError("Name", "Item with this value already exists.");
}
return(View("Edit", model));
}
public ActionResult AddGenre(GenreAddUpdateViewModel genreAddUpdateViewModel)
{
GenreLocalizationViewModel englishLocalization = GetLocalization(genreAddUpdateViewModel, "en");
if (IsLocalizationEmpty(englishLocalization))
{
ModelState.AddModelError("localizationError", "English localization should exist. ");
}
if (ModelState.IsValid)
{
CleanEmptyLocalizations(genreAddUpdateViewModel);
var genreModel = Mapper.Map <GenreModel>(genreAddUpdateViewModel);
_genreService.Add(genreModel);
MessageSuccess("The genre has been added successfully. ");
return(RedirectToAction("Get", "Genre"));
}
IEnumerable <GenreModel> genreModels = _genreService.GetAll();
genreAddUpdateViewModel.AllGenres = Mapper.Map <IEnumerable <GenreViewModel> >(genreModels);
return(View(genreAddUpdateViewModel));
}
public void Post([FromBody] GenreViewModel value)
{
GenreDTO genre = new GenreDTO()
{
GenreId = value.GenreId,
GenreName = value.GenreName
};
genreService.Add(genre);
}
public ValidationResult Create(Genre genre)
{
BeginTransaction();
ValidationResult.Add(_service.Add(genre));
if (ValidationResult.IsValid)
{
Commit();
}
return(ValidationResult);
}
public ActionResult Create(Genre genre)
{
if (ModelState.IsValid)
{
_genreService.Add(genre);
return(PartialView("Thanks"));
}
return(PartialView("_Create", genre));
}
public IActionResult AddNew([FromBody] Genre genre)
{
try
{
_genreService.Add(genre);
return(Ok());;
}
catch
{
return(BadRequest());
}
}
// Private methods
private async Task AttemptChangeAsync()
{
Name.Value = Name.Value?.Trim();
if (_validationHelper.Validate())
{
_userDialogs.ShowLoading((string.IsNullOrWhiteSpace(Id.Value) ? "Add" : "Update") + " genre");
var serviceResult = new ServiceResult <GenreModel>();
if (string.IsNullOrWhiteSpace(Id.Value))
{
serviceResult = await _genreService.Add(new GenreModel()
{
Id = Id.Value, Name = Name.Value
});
}
else
{
serviceResult = await _genreService.Update(new GenreModel()
{
Id = Id.Value, Name = Name.Value
});
}
if (serviceResult.Success)
{
await _navigationService.Close(this);
_userDialogs.HideLoading();
await _userDialogs.AlertAsync(new AlertConfig
{
Title = "Success!",
Message = serviceResult.Error.Description,
OkText = "OK"
});
}
else
{
_userDialogs.HideLoading();
await _userDialogs.AlertAsync(new AlertConfig
{
Title = (string.IsNullOrWhiteSpace(Id.Value) ? "Add" : "Update") + " failed",
Message = serviceResult.Error.Description,
OkText = "OK"
});
InitValidationCommand.Execute(null);
}
}
}
public IHttpActionResult Post(GenreViewModel genreViewModel)
{
if (!ModelState.IsValid)
{
return(Content(HttpStatusCode.BadRequest, CreateError()));
}
var genre = _mapper.Map <GenreViewModel, Genre>(genreViewModel);
_genreService.Add(genre, CurrentLanguage);
return(Ok());
}
public ActionResult AddGenre(GenreViewModel genreViewModel)
{
if (ModelState.IsValid)
{
var genre = _mapper.Map <GenreViewModel, Genre>(genreViewModel);
_genreService.Add(genre, CurrentLanguageCode);
return(RedirectToAction("GetGenres"));
}
genreViewModel.Genres = _mapper.Map <IEnumerable <Genre>, IList <GenreViewModel> >(_genreService.Get(CurrentLanguageCode));
return(View(genreViewModel));
}
public ActionResult Create(GenreEditModel model)
{
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var genre = new Genre {
Name = model.Name, Description = model.Description
};
_genreService.Add(genre);
return(View(model));
}
public static async Task SeedGenres(ApplicationDbContext context)
{
var genreDtos = await _dirble.GetCategoriesInTreeView();
Genre GetGenre(GenreDirbleDto genreDto)
{
var genre = new Genre
{
Id = genreDto.Id,
Name = genreDto.Title,
Description = String.IsNullOrWhiteSpace(genreDto.Description) ? null : genreDto.Description,
Slug = genreDto.Slug,
Urlid = String.IsNullOrWhiteSpace(genreDto.Urlid) ? null : genreDto.Urlid,
DateAdded = DateTimeOffset.Parse(genreDto.CreatedAt),
DateUpdated = DateTimeOffset.Parse(genreDto.UpdatedAt),
Position = genreDto.Position,
};
return(genre);
};
void AddChildGenres(Genre genre, GenreDirbleDto genreDto)
{
foreach (var child in genreDto.Children)
{
var childGenre = GetGenre(child);
genre.ChildGenres.Add(childGenre);
AddChildGenres(childGenre, child);
}
}
foreach (var genreDto in genreDtos)
{
var genre = GetGenre(genreDto);
AddChildGenres(genre, genreDto);
_genreService.Add(genre);
}
}
public ActionResult Add([Bind("Name")] Genre genre, string returnUrl = null)
{
ViewBag.returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var errors = _genreService.ValidateGenre(genre);
if (!errors.Any())
{
_genreService.Add(genre);
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Manage"));
}
ModelState.Merge(errors);
}
return(View(genre));
}
public async Task <Genre> Add()
{
return(await _service.Add(Rec, UserInfo.UserId));
}
public IActionResult Create(Genre genre)
{
_genreService.Add(genre);
return(RedirectToAction(nameof(Index)));
}
public IActionResult AddGenre(Genre genre)
{
genreService.Add(genre);
return(RedirectToAction("Index"));
}
