public IHttpActionResult CreatePublisher(PublisherModel model)
{
var publisher = Mapper.Map <PublisherModel, PublisherDTO>(model);
_publisherService.Create(publisher);
return(Ok("Publisher created"));
}
public int Create(CreatePublisherViewModel createPublisherViewModel)
{
Validate(createPublisherViewModel);
return(publisherService.Create(new CreatePublisherRequest()
{
LicenceNumber = createPublisherViewModel.LicenceNumber,
Name = createPublisherViewModel.Name
}));
}
private async Task <Publisher> GetOrGeneratePublisher(string name)
{
var publisher = _PublisherService.FindByName(name);
if (publisher == null)
{
publisher = await _PublisherService.Create(name);
}
return(publisher);
}
public async Task <ActionResult> Post([FromBody] PublisherDto dto)
{
try
{
return(Ok(await PublisherService.Create(dto)));
}
catch (BusinessRulesException e)
{
return(StatusCode((int)e.StatusCode, e.Message));
}
}
public ActionResult Create(PublisherViewModel model)
{
if (ModelState.IsValid)
{
var publisher = Mapper.Map <CreateUpdatePublisherInput>(model);
gameService.Create(publisher);
TempData["ResultMsg"] = "The publisher was added successfully!";
return(RedirectToAction("Details", "Publisher", new { companyName = model.CompanyName }));
}
TempData["ResultMsg"] = "Some fields of game is not valid!";
return(View(model));
}
public ActionResult AddPublisher(PublisherEditViewModel publisherEditViewModel)
{
if (!ModelState.IsValid)
{
return(View(publisherEditViewModel));
}
var publisher = Mapper.Map <Publisher>(publisherEditViewModel);
_publisherServices.Create(publisher);
return(RedirectToAction("Index"));
}
public IActionResult PostPublisher(string publisherName)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Publisher publisher = new Publisher();
publisher.CreatedDate = DateTime.UtcNow;
publisher.Name = publisherName;
_iPublisherService.Create(publisher);
return(CreatedAtAction("GetPublisher", new { id = publisher.Id }, publisher));
}
public void ShouldCreatePublisher()
{
_mock.Setup(m => m.Publishers.Create(It.IsAny <Publisher>()));
_mock.Setup(m => m.PublisherTranslations.Create(It.IsAny <PublisherTranslation>()));
_mock.Setup(m => m.Save());
_service.Create("companyName", new Dictionary <string, string>()
{
{ "ru", "описание" }
}, "homePage");
_mock.Verify(m => m.Publishers.Create(It.IsAny <Publisher>()), Times.AtLeastOnce);
_mock.Verify(m => m.PublisherTranslations.Create(It.IsAny <PublisherTranslation>()), Times.AtLeastOnce);
_mock.Verify(m => m.Save());
}
public async Task <IActionResult> Post([FromBody] CreatePublisherDTO dto)
{
var validator = new PublisherFluentValidator(_context);
var errors = await validator.ValidateAsync(dto);
if (!errors.IsValid)
{
return(UnprocessableEntity(ValidationFormatter.Format(errors)));
}
try {
await _publisherService.Create(dto);
return(StatusCode(201));
} catch (Exception) {
return(StatusCode(500, new { ServerErrorResponse.Message }));
}
}
public HttpResponseMessage Put([FromBody] CreatePublisherModel model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
IDictionary <string, string> descriptions = new Dictionary <string, string>();
descriptions.Add("ru", model.Description);
if (model.IsContainEnglishTranslation)
{
descriptions.Add("en", model.EnglishDescription);
}
int publisherId = _publisherService.Create(model.CompanyName, descriptions, model.HomePage);
return(Request.CreateResponse(HttpStatusCode.Created, publisherId));
}
public ActionResult Create(PublisherViewModel publisherView)
{
if (_publisherService.GetByName(publisherView.CompanyName) != null)
{
ModelState.AddModelError("CompanyName", Resources.Publisher.PublisherResource.CompanyNameExistsError);
}
if (ModelState.IsValid)
{
var publisher = Mapper.Map <PublisherViewModel, Publisher>(publisherView);
_publisherService.Create(publisher);
return(RedirectToAction("Index"));
}
else
{
return(View(publisherView));
}
}
public ActionResult CreatePublisher(PublisherViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IDictionary <string, string> descriptions = new Dictionary <string, string>();
descriptions.Add("ru", model.Description);
if (model.IsContainEnglishTranslation)
{
descriptions.Add("en", model.EnglishDescription);
}
_publisherService.Create(model.CompanyName, descriptions, model.HomePage);
return(RedirectToAction("GetPublisherByCompanyName", new { companyName = model.CompanyName }));
}
public void Create_should_throw_ArgumentNullException_when_input_entity_is_null()
{
// Act & Assert
Assert.Throws <ArgumentNullException>(() => _publisherService.Create(null));
}
public async Task <IActionResult> Create([FromBody] PublisherViewModel publisherVM)
{
var created = await _publisherService.Create(publisherVM.MapTo <Publisher>());
return(created ? Ok() as ActionResult : BadRequest());
}
