public override void CreateOne() { MockGenreRepository.Setup(r => r.Create(It.IsAny <Genre>())).Returns(MockGenre); var entity = _service.Create(MockGenreBO); Assert.NotNull(entity); }
public void createTest() { var id = genreService.Create(testName); var dbEntity = cdDb.Genres.SingleOrDefault(x => x.Id == id); Assert.IsNotNull(dbEntity); cdDb.Genres.Remove(dbEntity); cdDb.SaveChanges(); }
public ActionResult Create(GenreEditorModel genreEditorModel, string[] parentGenre) { if (_genreService.Get(genreEditorModel.Genre.Name) != null) { ModelState.AddModelError("Name", Resources.Genre.GenreResource.NameExistsError); } if (ModelState.IsValid) { var genre = Mapper.Map <GenreViewModel, Genre>(genreEditorModel.Genre); var parent = _genreService.Get(parentGenre[0]); if (parent != null) { genre.ParentId = parent.Id; } SetTranslate(genre.GenreTranslates, genreEditorModel.Genre); _genreService.Create(genre); return(RedirectToAction("Index")); } var genreModel = new GenreEditorModel { ParentGenres = CreateSelectList(), Genre = genreEditorModel.Genre, }; return(View(genreModel)); }
public IActionResult PostGenre([FromBody] GenreModel genreModel) { _logger.LogInformation($"{nameof(GenreController)} : {nameof(PostGenre)} was called."); try { if (genreModel == null) { return(BadRequest("Genre is required")); } if (_genreService.FindById(genreModel.Id) != null) { return(Conflict("Genre already exists")); } _genreService.Create(genreModel); _genreService.Save(); return(Ok("Genre Created")); } catch (DbException exception) { _logger.LogError(exception.Message); return(BadRequest(exception.Message)); } catch (Exception exception) { _logger.LogError(exception.Message); throw; } }
public async Task<IActionResult> CreateGenre(GenreViewModel model) { var genre = await _genreService.Create(model.ToDTO()); var genreViewModel = genre.ToViewModel(); return Created("post", genreViewModel); }
public IHttpActionResult CreateGenre(GenreModel model) { var genre = Mapper.Map <GenreModel, GenreDTO>(model); _genreService.Create(genre); return(Ok("Genre created")); }
public ActionResult Create(GenrePostModel model) { var genre = _mapper.Map <GenreModel>(model); _genreService.Create(genre); return(RedirectToAction("Index")); }
public int Create(CreateGenreViewModel createGenreViewModel) { Validate(createGenreViewModel); return(genreService.Create(new CreateGenreRequest() { Description = createGenreViewModel.Description, })); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } await _genreService.Create(GenreCreation); return(RedirectToPage("../GenreRazor/Index")); }
public async Task <ActionResult> Post(GenreDTO dto) { var result = await _genreService.Create(dto); if (result) { return(Ok()); } return(BadRequest()); }
public ActionResult CreateGenre(GenreDTO model) { if (ModelState.IsValid) { genreService.Create(model); return(RedirectToAction("AllGenres", "Libraryan")); } else { ModelState.AddModelError("", "Заполните все необходимые поля!"); } return(View()); }
public ActionResult Create(string name, int?idParent) { try { genreService.Create(name, idParent); string Message = "Genre Created"; InternalNotification.Success(Message); } catch (Exception ex) { InternalNotification.Error(ex); } return(RedirectToAction("index")); }
public async Task <IActionResult> Create([FromBody] GenreCreateRequest request) { try { var genre = await _genreService.Create(request); return(CreatedAtAction(nameof(Get), new { id = genre.Id }, genre)); } catch (Exception exception) { return(BadRequest(new { exception.Message })); } }
public HttpResponseMessage Put([FromBody] CreateGenreModel model) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } if (model.ParentGenreId != null && model.ParentGenreId == default(int)) { model.ParentGenreId = null; } int genreId = _genreService.Create(model.Name, model.ParentGenreId); return(Request.CreateResponse(HttpStatusCode.Created, genreId)); }
public async Task <IActionResult> Post([FromBody] CreateGenreDTO dto) { var validator = new GenreFluentValidator(_context); var errors = await validator.ValidateAsync(dto); if (!errors.IsValid) { return(UnprocessableEntity(ValidationFormatter.Format(errors))); } try { await _genreService.Create(dto); return(StatusCode(201)); } catch (Exception) { return(StatusCode(500, new { ServerErrorResponse.Message })); } }
public ActionResult New(CreateGenreViewModel model) { if (!ModelState.IsValid) { List <GenreDto> genres = _genreService.GetAllGenres().ToList(); genres.Insert(0, new GenreDto { Id = 0, Name = Resource.Default }); model.Genres = new SelectList(genres, "Id", "Name", genres.First().Id); return(View(model)); } if (model.ParentGenreId != null && model.ParentGenreId == default(int)) { model.ParentGenreId = null; } _genreService.Create(model.Name, model.ParentGenreId); return(RedirectToAction("GetAll")); }
public IActionResult Create([Bind("Id,Name,Color")] GenreViewModel genre) { if (ModelState.IsValid) { try { var newGenre = _mapper.Map <GenreViewModel, GenreDTO>(genre); _service.Create(newGenre); } catch (Exception e) { return(View("Error", new ErrorViewModel { RequestId = Request.HttpContext.TraceIdentifier, Exception = e })); } return(RedirectToAction(nameof(Index))); } return(View(genre)); }
public async Task Create(GenreDto dto) { var genre = _mapper.Map <Genre>(dto); await _genreService.Create(genre); }
public Task <int> Create(GenreInputDtos inputDto) { return(genreService.Create(inputDto)); }
public async Task <IActionResult> Post([FromBody] NewGenreDto data) { var result = await _genreService.Create(data); return(new JsonResult(result)); }
// POST: api/Genre public void Post(GenreViewModel genre) { var model = Mapper.Map <GenreModel>(genre); genreService.Create(model); }
public void Create_should_throw_ArgumentNullException_when_input_entity_is_null() { // Act & Assert Assert.Throws <ArgumentNullException>(() => _genreService.Create(null)); }
public ActionResult Create(GenreViewModel genre) { genreService.Create(mapper.Map <Genre>(genre)); return(RedirectToAction("Index")); }