public async Task AddClick(int postId)
{
var click = new Click {
DateTime = DateTime.Now, PostId = postId
};
await clickRepository.AddAsync(click);
}
public async Task <Response> Handle(CreateBlogCommand request, CancellationToken cancellationToken)
{
var blog = new Blog(request.Url, "c");
await _blogRepository.AddAsync(blog);
return(new Response("Book criado com sucesso"));
}
public async Task <Blog> AddBlog([FromBody] Blog blog)
{
await _blogRepository.AddAsync(blog);
await _blogRepository.SaveAsync();
return(blog);
}
public async Task CreateBlog(BlogDto dto)
{
var entity = _mapper.Map <BlogEntity>(dto);
entity.CreatedAt = DateTime.UtcNow;
await _blogRepository.AddAsync(entity);
}
public async Task <long> AddAsync(BlogSave obj)
{
Blogmodel blog = new Blogmodel()
{
userId = obj.userId,
blogContent = obj.blogContent
};
return(await _repository.AddAsync(blog));
}
public async Task <BlogDTO> AddAsync(NewBlogDTO newDTO)
{
var model = _mapper.Map <Blog>(newDTO);
var newModel = await _repository.AddAsync(model);
// Call the second repository method here.
// Commit the database changes from both repositories.
_session.GetUnitOfWork().CommitChanges();
return(_mapper.Map <BlogDTO>(newModel));
}
public async Task <Guid> Handle(AddBlogRequest request, CancellationToken cancellationToken)
{
//TODO: Check if name already Exist
//TODO: Check if the user can create new blog
Guid Id = repository.NextIdentifier();
await repository.AddAsync(new Domain.Blog.Entities.Blog
{
Id = Id,
Name = request.Name,
OwnerId = request.OwnerId
}, cancellationToken);
return(Id);
}
public async Task <BlogDto> AddBlogAsync(BlogDto blog)
{
/*
* var category = await _categoryRepository.FindCategoryByNameWithBlogsAsync(blog.Category.Name);
* if(category == null)
* {
* throw new ResourceNotFoundException("Category with id " + blog.Category.Name + " not found" );
* }
*/
var blogEntity = _mapper.Map <BlogDto, BlogEntity>(blog);
//blogEntity.Category = category;
var result = await _blogRepository.AddAsync(blogEntity);
await _blogRepository.SaveAsync();
var resultDto = _mapper.Map <BlogEntity, BlogDto> (result);
return(resultDto);
}
public async Task <IActionResult> BlogSave(Blog blog)
{
if (blog != null)
{
var file = Request.Form.Files.First();
string savePath = Path.Combine("wwwroot", "Images");
var fileName = $"{DateTime.Now:MMddHHmmss}.{file.FileName.Split(".").Last()}";
var fileUrl = Path.Combine(savePath, fileName);
using (var fileStream = new FileStream(fileUrl, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
blog.BannerUrl = "\\Images\\" + fileName;
int?userId = HttpContext.Session.GetInt32("id");
blog.UserId = userId.Value;
blog.IsPublish = true;
await _blogRepo.AddAsync(blog);
return(Json(true));
}
return(Json(false));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
if (PicturFile != null && PicturFile.Length > 0)
{
if (StorageHelper.IsImage(PicturFile))
{
var uploadedPic = await _commandHelper.UploadFileAsync(PicturFile, FileType.Image);
Blog.PhotoUrl = uploadedPic.FileUrl;
}
else
{
ModelState.AddModelError("PhotoUrl", "Please select image type file");
return(Page());
}
}
if (Request.Form.Files.Count > 0)
{
Attachments = Request.Form.Files.Where(x => x.Name.Contains("Attachments")).ToList();
if (Attachments.Count > 0)
{
Blog.Attachments = new Attachment[Attachments.Count];
for (var i = 0; i < Attachments.Count; i++)
{
Blog.Attachments[i] = await _commandHelper.UploadFileAsync(Attachments[i], FileType.File);
}
}
}
Blog.CreationDate = DateTime.Now;
await _context.AddAsync(Blog);
return(RedirectToPage("./Index"));
}
private async Task SyncPostCategories(Post post, IList <int> categoryIds)
{
var current = await GetCategoryIdsInPostAsync(post);
var needRemoveIds = current.Where(i => !categoryIds.Contains(i));
if (!needRemoveIds.IsNullOrEmpty())
{
var spec = new PostCategoryFilterSpecification(post, needRemoveIds.ToList());
var removeItems = await postsCategoriesRepository.ListAsync(spec);
postsCategoriesRepository.DeleteRange(removeItems);
}
var needToAdd = categoryIds.Where(i => !current.Contains(i));
if (!needToAdd.IsNullOrEmpty())
{
foreach (var newCategoryId in needToAdd)
{
await postsCategoriesRepository.AddAsync(new PostCategory { PostId = post.Id, CategoryId = newCategoryId });
}
}
}
private void MockPosts()
{
_blogRepository.AddAsync(new BlogPost(Guid.NewGuid(), "Neque porro quisquam est qui dolorem ipsum", DateTime.Now, "Fashion"));
_blogRepository.AddAsync(new BlogPost(Guid.NewGuid(), "Neque porro quisquam est qui dolorem ipsum", DateTime.Now, "Fashion"));
_blogRepository.AddAsync(new BlogPost(Guid.NewGuid(), "Neque porro quisquam est qui dolorem ipsum", DateTime.Now, "Fashion"));
}
public async Task <Post> CreateAsync(Post post)
{
return(await postRepository.AddAsync(post));
}
public async Task AddAsync(string text, DateTime publishedAt)
{
await _blogRepository.AddAsync(new Entities.BlogPost(Guid.NewGuid(), text, publishedAt));
}
