/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public CreateArticleResponse CreateArticle(CreateArticleRequest request)
{
using (var client = DbFactory.GetClient())
{
var article = new Article
{
ArticleTypeId = request.ArticleTypeId,
CategoryId = request.CategoryId,
Title = request.Title,
SubTitle = request.SubTitle,
TitleColor = request.TitleColor,
TitleBold = request.TitleBold,
Summary = request.Summary,
Content = request.Content,
Tags = request.Tags,
ThumbImage = request.ThumbImage,
Video = request.Video,
Source = request.Source,
Author = request.Author,
Hits = request.Hits,
Addtime = request.Addtime,
OrderIndex = request.OrderIndex,
IsTop = request.IsTop,
IsRecommend = request.IsRecommend,
SeoTitle = request.SeoTitle,
SeoKeyword = request.SeoKeyword,
SeoDescription = request.SeoDescription,
String1 = request.String1,
String2 = request.String2,
String3 = request.String3,
String4 = request.String4,
Int1 = request.Int1,
Int2 = request.Int2,
Int3 = request.Int3,
Int4 = request.Int4,
Decimal1 = request.Decimal1,
Decimal2 = request.Decimal2,
Decimal3 = request.Decimal3,
Decimal4 = request.Decimal4,
Datetime1 = request.Datetime1,
Datetime2 = request.Datetime2,
Datetime3 = request.Datetime3,
Datetime4 = request.Datetime4,
Bool1 = request.Bool1,
Bool2 = request.Bool2,
Bool3 = request.Bool3,
Bool4 = request.Bool4,
Text1 = request.Text1,
Text2 = request.Text2,
Text3 = request.Text3,
Text4 = request.Text4
};
article.Id = client.Insertable(article).ExecuteReturnBigIdentity();
//_cacheManager.RemoveOnEntityCreated<Article>();
_eventPublisher.EntityCreated(article);
return(new CreateArticleResponse());
}
}
public void Post_Article_Should_Return_BadRequest_Response_When_Creating_Article_With_Same_Title(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = false,
PublishDate = null,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage2,
out string createResponseString2,
out ArticleResponse createArticleResponse2);
Assert.AreEqual(HttpStatusCode.BadRequest, createHttpResponseMessage2.StatusCode);
}
private static void CreateArticle()
{
Console.WriteLine("\n");
Console.Write("Title : ");
var title = Console.ReadLine()?.Trim();
Console.Write("Content : ");
var content = Console.ReadLine()?.Trim();
// we generate a random author id for the sake of simplicity
var authorId = Guid.Parse("5F78060C-52EF-4190-A23A-B3F755A7DE28");
Console.Write($"Author ID: {authorId}");
Console.WriteLine("\n");
var createArticleRequest = new CreateArticleRequest(
new Title(title),
new Content(content),
new AuthorId(authorId));
var articleIdResponse = _articles.Create(createArticleRequest);
Console.WriteLine(articleIdResponse);
}
public ArticleStruct SaveStubToSitecore(string articleName, DateTime publicationDate, Guid publicationID)
{
using (var client = new HttpClient(_handler, false))
{
publicationDate = TimezoneUtil.ConvertDateToServerTimezone(publicationDate);
//Passing string format to create Article(Ticket IIS-589)
var publicationDateString = publicationDate.ToString(System.Globalization.CultureInfo.GetCultureInfo("en-US"));
var article = new CreateArticleRequest()
{
Name = articleName, PublicationID = publicationID, PublicationDate = publicationDateString
};
var response = client.PostAsJsonAsync($"{$"{Constants.EDITOR_ENVIRONMENT_SERVERURL}" + "/api/"}CreateArticle", article).Result;
if (response?.StatusCode != HttpStatusCode.OK)
{//If the response is not OK, place the status code into the remote error message for logging
return(new ArticleStruct {
RemoteErrorMessage = response?.StatusCode.ToString()
});
}
else
{
var articleItem = JsonConvert.DeserializeObject <ArticleStruct>(response.Content.ReadAsStringAsync().Result, new IsoDateTimeConverter());
TimezoneUtil.ConvertArticleDatesToLocalTimezone(articleItem);
return(articleItem);
}
}
}
public void UnLike_Article_When_Called_Multiple_Times_Should_Return_BadRequest(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = true,
PublishDate = DateTime.UtcNow,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
for (int i = 0; i < 3; i++)
{
LikeArticle(createArticleResponse.Id, dataFormat, out HttpResponseMessage unLikeArticleHttpResponseMessage, out string unLikeArticleResponseString);
}
LikeArticle(createArticleResponse.Id, dataFormat, out HttpResponseMessage unLikeArticleHttpResponseMessage2, out string unLikeArticleResponseString2);
Assert.AreEqual(HttpStatusCode.BadRequest, unLikeArticleHttpResponseMessage2.StatusCode);
}
public ArticleStruct Post([FromBody] CreateArticleRequest content)
{
try
{
var publicationDate = DateTime.Parse(content.PublicationDate);
var parent = _articleUtil.GenerateDailyFolder(content.PublicationID, publicationDate);
var rinsedName = ItemUtil.ProposeValidItemName(content.Name);
var articleCreate = _sitecoreMasterService.Create <IArticle, IArticle_Date_Folder>(parent, rinsedName);
//Hack to start the workflow
var articleItem = _sitecoreMasterService.GetItem <Item>(articleCreate._Id);
var savedArticle = _sitecoreMasterService.GetItem <ArticleItem>(articleCreate._Id);
//var intialWorkflow = _sitecoreMasterService.Database.WorkflowProvider.GetWorkflow("{926E6200-EB76-4AD4-8614-691D002573AC}");
var intialWorkflow = _sitecoreMasterService.Database.WorkflowProvider.GetWorkflow(savedArticle.Crawl <ISite_Root>().Workflow.ToString());
intialWorkflow.Start(articleItem);
var article = _sitecoreMasterService.GetItem <IArticle__Raw>(articleCreate._Id);
article.Title = content.Name;
article.Planned_Publish_Date = publicationDate;
article.Created_Date = DateTime.Now;
article.Article_Number = SitecoreUtil.GetNextArticleNumber(_articleSearch.GetNextArticleNumber(content.PublicationID), content.PublicationID);
_sitecoreMasterService.Save(article);
savedArticle = _sitecoreMasterService.GetItem <ArticleItem>(articleCreate._Id);
var articleStruct = _articleUtil.GetArticleStruct(savedArticle);
return(articleStruct);
}
catch (Exception ex)
{
return(new ArticleStruct {
RemoteErrorMessage = ex.ToString()
});
}
}
/// Create operation for Article entity
/// <inheritdoc/>
public override async Task <ArticleModel> CreateArticle(CreateArticleRequest request, ServerCallContext context)
{
var validator = this.validatorFactory.GetValidator <CreateArticleRequest>();
var result = await validator.ValidateAsync(request);
if (!result.IsValid)
{
this.logger.LogInformation($"Validation error occurred");
throw new RpcException(
new Status(StatusCode.InvalidArgument, "Validation error"));
}
var article = await this.articlesRepository.CreateAsync(
new Article(
request.User, request.Title, request.Content, request.ThumbnailImage.ToByteArray()));
return(new ArticleModel
{
ArticleId = article.Id,
Content = article.Content,
Title = article.Title,
ThumbnailImage = ByteString.CopyFrom(article.Thumbnail),
User = article.Username,
});
}
public void UnLike_Article_Should_Create_ArticleFeedback(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = true,
PublishDate = DateTime.UtcNow,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
UnLikeArticle(createArticleResponse.Id, dataFormat, out HttpResponseMessage unLikeArticleHttpResponseMessage, out string unLikeArticleResponseString);
Assert.AreEqual(HttpStatusCode.NoContent, unLikeArticleHttpResponseMessage.StatusCode);
}
public async Task Delete_Article_Should_Delete(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = false,
PublishDate = null,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
var response = await Client.DeleteAsync($"api/v1/articles/{createArticleResponse.Id}");
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
GetArticle(createArticleResponse.Id, out HttpResponseMessage getHttpResponseMessage, out string getResponseString, out ArticleResponse getArticleResponse);
Assert.AreEqual(HttpStatusCode.NotFound, getHttpResponseMessage.StatusCode);
}
public void SetUp()
{
createRequest = new CreateArticleRequest()
{
Title = "title",
Content = "content",
Category = ArticleCategoryType.News,
Image = It.IsAny <IFormFile>()
};
updateRequest = new UpdateArticleRequest()
{
ArticleId = It.IsAny <string>(),
Title = "title",
Content = "content",
Category = ArticleCategoryType.News,
Image = It.IsAny <IFormFile>(),
IsImageDeleted = false
};
database = new Mock <IDatabase>();
filesManager = new Mock <IFilesManager>();
mapper = new Mock <IMapper>();
articleService = new ArticleService(database.Object, filesManager.Object, mapper.Object);
}
public async Task <Article> Create(CreateArticleRequest request)
{
request.Article.HasText = !string.IsNullOrEmpty(request.Text);
request.Article.Translations = null; // Ignore translations when creating the article
var articleEntity = _mapper.Map <ArticleEntity>(request.Article);
await _dbContext.Articles.InsertOneAsync(articleEntity);
var article = _mapper.Map <Article>(articleEntity);
// Create text file in S3
if (!string.IsNullOrEmpty(request.Text))
{
var result = await UploadS3File(
GetTextFilename(article),
request.Text
);
if (!result)
{
// Clean up
await Delete(article.Id);
throw new Exception($"Error uploading article {request.Article.Id} to storage");
}
article.TextLink = GetTextLink(article);
}
return(article);
}
public IHttpActionResult CreateArticle(CreateArticleRequest request)
{
var command = _mapper.Map <CreateArticleCommand>(request);
_commandBus.Send(command);
return(Ok());
}
public ArticleIdResponse Create(CreateArticleRequest createArticleRequest)
{
var(title, content, authorId) = createArticleRequest;
var articleId = _articleService.Create(authorId, title, content);
return(new ArticleIdResponse(articleId));
}
public async Task <IActionResult> CreateArticle([FromForm] CreateArticleRequest request)
{
var response = await mediator.Send(request);
Log.Information($"User #{HttpContext.GetCurrentUserId()} created new article #{response.Article?.Id}");
return(this.CreateResponse(response));
}
public async Task <IActionResult> Post([FromBody] CreateArticleRequest createArticleRequest)
{
var article = mapper.Map <Article>(createArticleRequest);
await articleService.CreateAsync(article);
var articleResponse = mapper.Map <Article, ArticleResponse>(article);
return(CreatedAtRoute(nameof(GetArticle), new { id = articleResponse.Id }, articleResponse));
}
public async Task <CreateArticleResponse> Create(CreateArticleRequest request)
{
request.ValidateAndThrow();
var result = await _articlesService.Create(request);
return(new CreateArticleResponse
{
Article = result
});
}
private void CreateArticle(CreateArticleRequest createArticleRequest, DataFormat dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse)
{
CreateHttpClient().Post("api/v1/articles",
createArticleRequest, dataFormat,
out createHttpResponseMessage,
out createResponseString,
out createArticleResponse);
}
public async Task <ArticleDetails> CreateArticleAsync(string userId, [FromBody] CreateArticleRequest createArticle)
{
createArticle.UserId = userId;
var user = await this.GetUserAsync(createArticle.UserId);
var article = await this.articleService.CreateArticleAsync(createArticle);
await this.userService.AddArticlesToUserAsync(user, new string[] { article.Id });
return(article);
}
/// <summary>
/// Create an article in the specified folder.
///
/// c.f. https://developers.freshdesk.com/api/#solution_article_attributes
/// </summary>
///
/// <param name="folderId">
/// The unique identifier of the folder which the article will reside within.
/// </param>
///
/// <param name="request">
/// The properties to set on the article.
/// </param>
///
/// <param name="cancellationToken"></param>
///
/// <returns>The newly created article with ID filled in.</returns>
public async Task <Article> CreateArticleAsync(
long folderId,
CreateArticleRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "The request must not be null");
}
return(await _freshdeskClient.ApiOperationAsync <Article>(HttpMethod.Post, $"/api/v2/solutions/folders/{folderId}/articles", request, cancellationToken).ConfigureAwait(false));
}
public void Post_Article_Should_Return_BadRequest_Response_When_Creating_Article_With_No_Data(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest();
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.BadRequest, createHttpResponseMessage.StatusCode);
}
public void CreateArticle_ReceivesCreateArticleRequest_ExpectsArticleModel()
{
var username = "******";
var title = "My Article 1";
var content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
var thumbnail = new byte[] { 72, 101, 108, 108, 111 };
var newArticle = new Article(
username,
title,
content,
thumbnail);
var mockArticlesRepo = new Mock <IArticlesRepository>();
mockArticlesRepo
.Setup(x => x.CreateAsync(It.IsAny <Article>()))
.ReturnsAsync(newArticle);
var mockCommentsRepo = new Mock <ICommentsRepository>();
var mockLogger = new Mock <ILogger <ArticlesService> >();
var mockValidationFactory = new Mock <IValidatorFactory>();
mockValidationFactory.Setup(x =>
x.GetValidator <CreateArticleRequest>()).Returns(new CreateArticleRequestValidator());
var mockContext = GetServerCallContext("CreateArticle");
var service = new ArticlesService(
mockLogger.Object,
mockArticlesRepo.Object,
mockCommentsRepo.Object,
mockValidationFactory.Object);
var request = new CreateArticleRequest
{
User = username,
Title = title,
Content = content,
ThumbnailImage = ByteString.CopyFrom(thumbnail),
};
var result = service.CreateArticle(request, mockContext).Result;
Assert.Equal(result.User, request.User);
Assert.Equal(result.Title, request.Title);
Assert.Equal(result.Content, request.Content);
Assert.Equal(result.ThumbnailImage, request.ThumbnailImage);
}
public void Put_Article_Should_Update_Article(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = false,
PublishDate = null,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
var updateArticleRequest = new UpdateArticleRequest()
{
Author = GetUniqueStringValue(createArticleRequest.Author),
Body = GetUniqueStringValue(createArticleRequest.Body),
IsPublished = createArticleRequest.IsPublished,
PublishDate = createArticleRequest.PublishDate,
Title = GetUniqueStringValue(createArticleRequest.Title)
};
UpdateArticle(createArticleResponse.Id, updateArticleRequest, dataFormat, out HttpResponseMessage updateHttpResponseMessage, out string updateResponseString);
Assert.AreEqual(HttpStatusCode.NoContent, updateHttpResponseMessage.StatusCode);
GetArticle(createArticleResponse.Id,
out HttpResponseMessage getHttpResponseMessage,
out string getResponseString,
out ArticleResponse getArticleResponse);
getHttpResponseMessage.EnsureSuccessStatusCode();
Assert.AreEqual(HttpStatusCode.OK, getHttpResponseMessage.StatusCode);
Assert.AreEqual(updateArticleRequest.Title, getArticleResponse.Title);
Assert.AreEqual(updateArticleRequest.Body, getArticleResponse.Body);
Assert.AreEqual(updateArticleRequest.Author, getArticleResponse.Author);
Assert.AreEqual(updateArticleRequest.IsPublished, getArticleResponse.IsPublished);
Assert.AreEqual(updateArticleRequest.PublishDate, getArticleResponse.PublishDate);
}
public async Task <ArticleDetails> CreateArticleAsync(CreateArticleRequest created)
{
var category = await this.categoryService.GetCategory(created.CategoryId);
var dbArticle = this.mapper.Map <DbArticle>(created);
this.CheckCreateArticleConflicts(dbArticle);
dbArticle.Comments = new List <DbComment>();
await this.context.Articles.InsertOneAsync(dbArticle);
await this.categoryService.AddArticleToCategory(category, dbArticle.Id);
return(this.mapper.Map <ArticleDetails>(dbArticle));
}
public async Task CreateArticle_ImageUploadedAndInsertingSucceeded_ReturnArticle()
{
createRequest = createRequest with {
Image = It.IsNotNull <IFormFile>()
};
database.Setup(d => d.ArticleRepository.Insert(It.IsNotNull <Article>(), false))
.ReturnsAsync(true);
database.Setup(d => d.ArticleRepository.Update(It.IsNotNull <Article>()))
.ReturnsAsync(true);
var result = await articleService.CreateArticle(createRequest);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf <Article>());
}
/// <summary>
/// Create a translation of the specified article into the specified
/// language.
///
/// c.f. https://developers.freshdesk.com/api/#solution_article_attributes
/// </summary>
///
/// <param name="articleId">
/// The unique identifier for the article.
/// </param>
///
/// <param name="languageCode">
/// The language code (e.g. es) which the translation corresponds to.
/// </param>
///
/// <param name="request">
/// The properties of the article to set.
/// </param>
///
/// <param name="cancellationToken"></param>
///
/// <returns>The newly translated article</returns>
public async Task <Article> CreateArticleTranslationAsync(
long articleId,
string languageCode,
CreateArticleRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "The request must not be null");
}
if (string.IsNullOrWhiteSpace(languageCode))
{
throw new ArgumentOutOfRangeException(nameof(languageCode), languageCode, "The language code must not be empty");
}
return(await _freshdeskClient.ApiOperationAsync <Article>(HttpMethod.Post, $"/api/v2/solutions/articles/{articleId}/{languageCode}", request, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc/>
public async Task <Article> CreateArticleAsync(CreateArticleRequest createRequest)
{
var dbArticles = await _articles.Articles.Where(article => article.Title == createRequest.Title).ToArrayAsync();
if (dbArticles.Length > 0)
{
throw new RequestedResourceHasConflictException("title");
}
var dbArticle = _mapper.Map <CreateArticleRequest, DbArticle>(createRequest);
dbArticle.CreatedDate = DateTime.Now;
_articles.Articles.Add(dbArticle);
await _articles.SaveChangesAsync();
return(_mapper.Map <Article>(dbArticle));
}
public async Task <IActionResult> CreateArticle(CreateArticleUserData request)
{
var quest = new CreateArticleRequest
{
ArticleUniqueIdentifier = Guid.NewGuid(),
Body = request.Body,
Description = request.Description,
Title = request.Title
};
var response = await _repo.CreateArticleAsync(quest);
if (response)
{
return(CreatedAtRoute("GetArticle", new { Controller = "Article", ArticleUniqueIdentity = quest.ArticleUniqueIdentifier },
new { quest.ArticleUniqueIdentifier, quest.Body, quest.Description, quest.Title }));
}
return(BadRequest("Unable to create article"));
}
public void Put_Article_Should_Return_BadRequest_Response_When_Creating_Article_With_Invalid_Data(DataFormat dataFormat)
{
ArticleResponse CreateArticleRequestAndAssert()
{
var createArticleRequest = new CreateArticleRequest()
{
Title = GetUniqueStringValue("title_"),
Body = GetUniqueStringValue("body_"),
IsPublished = false,
PublishDate = null,
Author = "God",
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.Created, createHttpResponseMessage.StatusCode);
Assert.AreEqual(createArticleRequest.Title, createArticleResponse.Title);
Assert.AreEqual(createArticleRequest.Body, createArticleResponse.Body);
Assert.AreEqual(createArticleRequest.Author, createArticleResponse.Author);
Assert.IsTrue(createArticleResponse.Id > 1);
return(createArticleResponse);
}
var createArticleResponse1 = CreateArticleRequestAndAssert();
var createArticleResponse2 = CreateArticleRequestAndAssert();
var updateArticleRequest = new UpdateArticleRequest()
{
Title = null,
Body = GetUniqueStringValue("body_"),
IsPublished = true,
PublishDate = DateTime.UtcNow,
Author = "God",
};
UpdateArticle(createArticleResponse2.Id, updateArticleRequest, dataFormat, out HttpResponseMessage updateHttpResponseMessage, out string updateResponseString);
Assert.AreEqual(HttpStatusCode.BadRequest, updateHttpResponseMessage.StatusCode);
}
public void Post_Article_Should_Return_BadRequest_Response_When_Creating_Article_Invalid_Data(DataFormat dataFormat)
{
var createArticleRequest = new CreateArticleRequest()
{
Title = null,
Body = null,
IsPublished = false,
PublishDate = null,
Author = null,
};
CreateArticle(createArticleRequest,
dataFormat,
out HttpResponseMessage createHttpResponseMessage,
out string createResponseString,
out ArticleResponse createArticleResponse);
Assert.AreEqual(HttpStatusCode.BadRequest, createHttpResponseMessage.StatusCode);
}
public ActionResult <ArticleIdResponse> Create(
[FromForm][Required] string title,
[FromForm][Required] string content,
[FromForm][Required] Guid authorId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createArticleRequest = new CreateArticleRequest(
new Title(title),
new Content(content),
new AuthorId(authorId));
var articleIdResponse = _articles.Create(createArticleRequest);
return(Ok(articleIdResponse));
}
