public async Task <IActionResult> CreateBlog([FromForm] CreateBlogRequest request)
{
var course = await _courseRepository.GetCourseById(request.CourseId);
if (course == null)
{
return(BadRequest());
}
var currentUserId = GetUserId();
if (currentUserId != course.TutorId && currentUserId != course.CustomerId)
{
return(BadRequest());
}
if (currentUserId != request.AuthorId)
{
return(BadRequest());
}
var courseBlog = new CourseBlog
{
AuthorId = (int)currentUserId,
CourseId = request.CourseId,
CreationDateTimeUtc = DateTime.UtcNow,
Text = request.BlogText
};
await _courseRepository.AddCourseBlog(courseBlog);
return(RedirectToAction("GetCourseView", new { id = request.CourseId }));
}
public async override Task <CreateBlogReply> CreateBlog(CreateBlogRequest request, ServerCallContext context)
{
InitBlogs();
if (!string.IsNullOrWhiteSpace(request.Code) && !blogs.Any(b => b.Code.Equals(request.Code)))
{
blogs.Add(new BlogModel
{
Code = request.Code,
Name = request.Name,
Title = request.Title,
Descript = request.Descript,
NumberWord = request.NumberWord,
Id = Guid.NewGuid().ToString()
});
redisManager.SetString(nameof(BlogService), JsonConvert.SerializeObject(blogs));
return(new CreateBlogReply
{
Success = true,
RequestValues = JsonConvert.SerializeObject(request)
});
}
return(new CreateBlogReply
{
Success = false,
RequestValues = "已存在相同的博客或者请求blog code is empty"
});
}
public async void CreateBlog_ValidCreateBlogRequest_ReturnsTrue()
{
var createBlogRequest = new CreateBlogRequest("New blog title", "New blog content", "New description", "New image url");
var result = await _blogService.CreateNewBlog(createBlogRequest);
Assert.True(result);
}
public async void CreateBlog_InvalidCreateBlogRequest_ReturnsFalse()
{
var createBlogRequest = new CreateBlogRequest("", "", "", "");
var result = await _blogService.CreateNewBlog(createBlogRequest);
Assert.False(result);
}
public async Task <IActionResult> Create([FromBody] CreateBlogRequest createRequest, CancellationToken cancellationToken)
{
var blog = new Blog(Guid.NewGuid(), createRequest.Url);
_dbContext.Add(blog);
await _dbContext.SaveChangesAsync(cancellationToken);
return(CreatedAtRoute(nameof(GetById), new { id = blog.Id }, blog));
}
private Blog Map(CreateBlogRequest blogRequest)
{
Blog blog = new Blog();
blog.Body = blogRequest.Body;
blog.Tags = blogRequest.Tags;
blog.Title = blogRequest.Title;
blog.Description = blogRequest.Description;
return(blog);
}
public async Task <BlogViewModel> WriteABlog(int id, [FromBody] CreateBlogRequest request)
{
var author = await _dbContext.Authors.FindAsync(id);
EnsureAuthorExists(author);
var cmd = new WriteBlogCommand(request.Title, request.Content);
var blog = author.WriteBlog(cmd);
await _dbContext.SaveChangesAsync();
return(new BlogViewModel(blog));
}
private async ValueTask <Blog> CreateRandomBlog(HttpClient client)
{
// Arrange
var createRequest = new CreateBlogRequest
{
Url = "https://aspnet-core-is-cool.net"
};
// Act
var postResponse = await client.PostAsync("/v1/blogs", new JsonContent <CreateBlogRequest>(createRequest));
postResponse.EnsureSuccessStatusCode();
return(await postResponse.Content.ReadAsJsonAsync <Blog>());
}
public async Task <ActionResult <Blog> > AddBlog([FromBody] CreateBlogRequest blockRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
blockRequest.UserName = HttpContext.User.Identity.Name;
var block = await _blockService.CreateBlogAsync(blockRequest);
var uri = $"/blogs/{block.Id}";
return(Created(uri, block));
}
public override async Task <CreateBlogResponse> CreateBlog(CreateBlogRequest request, ServerCallContext context)
{
var blog = request.Blog;
BsonDocument doc = new BsonDocument("author_id", blog.AuthorId)
.Add("title", blog.Title)
.Add("content", blog.Content);
await mongoCollection.InsertOneAsync(doc);
string id = doc.GetValue("_id").ToString();
blog.Id = id;
return(new CreateBlogResponse {
Blog = blog
});
}
public override Task <CreateBlogResponse> CreateBlog(CreateBlogRequest request, ServerCallContext context)
{
var blog = request.Blog;
BsonDocument doc = new BsonDocument("auther_id", blog.AuthorId)
.Add("title", blog.Title)
.Add("Content", blog.Content);
mongoCollection.InsertOne(doc);
String id = doc.GetValue("_id").ToString();
blog.Id = id;
return(Task.FromResult(new CreateBlogResponse()
{
Blog = blog
}));
}
public async Task <IActionResult> PostBlogs(CreateBlogRequest blogRequest)
{
try
{
Blog blog = new Blog(blogRequest.BlogPost);
List <string> tagList = blogRequest.BlogPost.TagList;
List <Tag> tagsForBlog = new List <Tag>();
SlugHelper slugHelper = new SlugHelper();
String newSlug = slugHelper.GenerateSlug(blogRequest.BlogPost.Title);
if (_context.Blog.Any(b => b.Slug == newSlug))
{
return(BadRequest(new ClientErrorResponse("Please enter a new title")));
}
foreach (string tag in tagList)
{
Tag t = _context.Tag.Where(t => t.Name == tag).FirstOrDefault();
if (t == null)
{
t = new Tag(tag);
}
tagsForBlog.Add(t);
}
blog.Tags = tagsForBlog;
_context.Blog.Add(blog);
await _context.SaveChangesAsync();
return(Created($"api/posts/{blog.Slug}", new SingleBlogPostResponse(blog)));
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest(new ClientErrorResponse("Couldn't save blog.")));
}
catch (NullReferenceException)
{
return(UnprocessableEntity(new ClientErrorResponse("One or more attributes are invalid")));
}
catch (Exception e)
{
return(BadRequest(new ClientErrorResponse(e.Message)));
}
}
public async Task <bool> CreateNewBlog(CreateBlogRequest createBlogRequest)
{
var(title, content, description, imageUrl) = createBlogRequest;
if (string.IsNullOrWhiteSpace(title) ||
string.IsNullOrWhiteSpace(content) ||
string.IsNullOrWhiteSpace(description) ||
string.IsNullOrWhiteSpace(imageUrl))
{
return(false);
}
try
{
await _blogRepository.CreateNewBlog(title, content, description, imageUrl);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public async Task Create_ShouldCreateBlog()
{
// Arrange
var createRequest = new CreateBlogRequest
{
Url = "https://aspnet-core-is-cool.net"
};
var client = _factory.CreateClient();
// Act
var postResponse = await client.PostAsync("/v1/blogs", new JsonContent <CreateBlogRequest>(createRequest));
postResponse.EnsureSuccessStatusCode();
var blogCreateResponse = await postResponse.Content.ReadAsJsonAsync <Blog>();
// Assert - by calling the Get/id and comparing the results
var getResponse = await client.GetAsync($"/v1/blogs/{blogCreateResponse.Id}");
var blogGetResponse = await getResponse.Content.ReadAsJsonAsync <Blog>();
blogGetResponse.Should().BeEquivalentTo(blogCreateResponse);
}
public async Task <Blog> CreateBlogAsync(CreateBlogRequest blogRequest)
{
if (blogRequest.Text.Length >= 2000)
{
throw new RequestException("Blog has length more 2000 symbols.");
}
var blog = _mapper.Map <CreateBlogRequest, Blog>(blogRequest);
var dateTimeNow = DateTime.Now;
blog.CreatedOn = dateTimeNow;
blog.UpdatedOn = dateTimeNow;
var blogs = await _repository.GetAll();
if (blogs.Select(a => a.Title).Contains(blogRequest.Title))
{
throw new RequestException("Blog exists this title!");
}
await _repository.Create(blog);
return(blog);
}
public async Task <IActionResult> InsertBlog([FromQuery] CreateBlogRequest request)
{
var result = await blogClient.CreateBlogAsync(request);
return(Ok(result));
}
public Task <string> CreateAsync(CreateBlogRequest model)
{
return(Task.FromResult(model.ToJson()));
}
public object Post(CreateBlogRequest request)
{
return(this._BlogManager.CreateBlog(Map(request)));
}
public ActionResult <Blog> PostBlog(CreateBlogRequest blogRequest)
{
Blog savedBlog = _blogService.CreateBlog(_mapper.Map <Blog>(blogRequest));
return(CreatedAtAction(nameof(GetBlog), new { id = savedBlog.Id }, savedBlog));
}
public Task <string> Post([FromBody] CreateBlogRequest model)
{
return(_mediator.Send(model));
}
public async Task <CreateBlogResponse> Post([FromBody] CreateBlogRequest request)
{
return(await _createItemHandler.ProcessAsync(request));
}
public BlogResponse CreateBlog(CreateBlogRequest request)
{
return(_service.CreateBlog(request));
}
