public async Task <CustomApiResponse> Put([FromBody] PostsDto entity)
{
//var inputEntity = _mapper.Map<Posts>(entity);
//var result = await _postService.Update(inputEntity);
var result = await _postService.UpdatePost(entity);
return(new CustomApiResponse(entity.Id, result ? "Succeeded" : "Failed", !result));
}
public async Task <ResponseDto> UpdatePost(int postId, PostsDto posts)
{
var entity = this.postsMapper.Configuration.Map <M.Posts>(posts);
await this.userRepository.UpdatePost(postId, entity);
return(new ResponseDto {
});
}
public async Task <CustomApiResponse> Post([FromBody] PostsDto entity)
{
//var inputEntity = _mapper.Map<Posts>(entity);
//if (await _postService.IsExisted(entity.Name))
//{
// return new CustomApiResponse("PostName đã tồn tại", true);
//}
var result = await _postService.AddPost(entity);
return(new CustomApiResponse(result));
}
public async Task <string> AddPost(PostsDto postDto)
{
// add post to get post id
var postInput = _mapper.Map <Posts>(postDto);
var postId = await _postRepository.Add(postInput);
postDto.Id = Convert.ToInt32(postId);
await addTagAndCategories(postDto);
return(postId);
}
public async Task <IActionResult> Post([FromBody] PostsDto postDto)
{
//var post = new Posts() {
// Id = postDto.Id,
// Date = postDto.Date,
// Description = postDto.Description,
// Image = postDto.Image,
// UserId = postDto.UserId
//};
var post = _mapper.Map <Posts>(postDto);
await _postRepository.InsertPost(post);
return(Ok(post));
}
public async Task <bool> UpdatePost(PostsDto postDto)
{
// update post
var inputEntity = _mapper.Map <Posts>(postDto);
var result = await _postRepository.Update(inputEntity);
// delete tag and categories
await deleteTagAndCategories(postDto.Id.ToString());
// re insert tag and categories
await addTagAndCategories(postDto);
return(result);
}
/// <inheritdoc cref="IPostsService"/>
public async Task <PostsDto> GetUserPosts(string userId, SortParametersDto sortParameters, string search)
{
var postsEnumerable = Table;
if (!string.IsNullOrWhiteSpace(userId))
{
postsEnumerable = postsEnumerable.Where(post => post.AuthorId.Equals(userId));
}
if (!string.IsNullOrWhiteSpace(search))
{
postsEnumerable = postsEnumerable.Where(post => post.Title.Equals(search));
}
postsEnumerable = postsEnumerable
.Include(x => x.Author)
.Include(x => x.Author.Profile)
.Include(x => x.PostTags)
.Include(x => x.Comments);
IList <Post> postModel = sortParameters != null
? await SortPosts(postsEnumerable, sortParameters).ToListAsync()
: await postsEnumerable.ToListAsync();
var postsViewModel = new PostsDto();
if (sortParameters == null)
{
return(postsViewModel);
}
if (!sortParameters.DisplayType.Equals("grid"))
{
postsViewModel.Posts = postModel
.Skip((sortParameters.CurrentPage - 1) * sortParameters.PageSize)
.Take(sortParameters.PageSize).ToList();
}
else
{
postsViewModel.Posts = postModel;
}
postsViewModel.PageInfo = new PageInfo {
PageNumber = sortParameters.CurrentPage, PageSize = sortParameters.PageSize, TotalItems = postModel.Count
};
return(postsViewModel);
}
public ServiceResponse <PostsDto> Update(PostsDto postsDto)
{
var response = new ServiceResponse <PostsDto>(null);
try
{
_postsRepository.Update(new Posts
{
PostsId = postsDto.PostsId,
LanguagesId = postsDto.LanguagesId,
Title = postsDto.Title,
TitleSlug = postsDto.TitleSlug,
Summary = postsDto.Summary,
Content = postsDto.Content,
Keywords = postsDto.Keywords,
UserId = postsDto.UserId,
CategoryId = postsDto.CategoryId,
ImageBig = postsDto.ImageBig,
ImageMid = postsDto.ImageMid,
ImageSmall = postsDto.ImageSmall,
ImageSlider = postsDto.ImageSlider,
ImageMime = postsDto.ImageMime,
IsSlider = postsDto.IsSlider,
IsPicked = postsDto.IsPicked,
Hit = postsDto.Hit,
SliderOrder = postsDto.SliderOrder,
OptionalUrl = postsDto.OptionalUrl,
PostType = postsDto.PostType,
VideoUrl = postsDto.VideoUrl,
VideoEmbedCode = postsDto.VideoEmbedCode,
ImageUrl = postsDto.ImageUrl,
NeedAuth = postsDto.NeedAuth,
Visibility = postsDto.Visibility,
Status = postsDto.Status,
CreatedAt = postsDto.CreatedAt
});
response.IsSuccessful = true;
}
catch (Exception e)
{
response.ExceptionMessage = e.Message;
response.HasExceptionError = true;
}
return(response);
}
/// <inheritdoc cref="IPostsService"/>
public async Task <PostsDto> GetPosts(SortParametersDto sortParameters, string search, bool onlyWithComments = false)
{
var postsQueryable = GetAll();
if (!string.IsNullOrWhiteSpace(search))
{
postsQueryable = postsQueryable.Where(post => post.Title.Equals(search));
}
var postModel = await postsQueryable
.Include(x => x.Author)
.Include(x => x.Author.Profile)
.Include(x => x.Comments)
.Include(x => x.PostTags)
.ToListAsync();
if (onlyWithComments)
{
postModel = postModel.Where(x => x.Comments.Count > 0).ToList();
}
var postsDto = new PostsDto()
{
Posts = postModel
};
if (sortParameters == null)
{
return(postsDto);
}
postsDto.Posts = SortPosts(postsDto.Posts.AsQueryable(), sortParameters).ToList();
if (sortParameters.DisplayType != null && !sortParameters.DisplayType.Equals("grid"))
{
postsDto.Posts = postModel
.Skip((sortParameters.CurrentPage - 1) * sortParameters.PageSize)
.Take(sortParameters.PageSize).ToList();
}
postsDto.PageInfo = new PageInfo {
PageNumber = sortParameters.CurrentPage, PageSize = sortParameters.PageSize, TotalItems = postModel.Count
};
return(postsDto);
}
async Task <string> addTagAndCategories(PostsDto postDto)
{
var postId = postDto.Id;
// add cats to postcat
var postCatDtos = new List <PostInCategoriesDto>();
var postTagDtos = new List <PostInTagsDto>();
// add categories
var catIds = postDto.categoryIds;
var resultAddPostCat = "Fail";
if (catIds.Count > 0)
{
foreach (var catId in catIds)
{
postCatDtos.Add(new PostInCategoriesDto()
{
PostId = postId,
CategoryId = catId,
});
}
var postCatInputs = _mapper.Map <List <PostInCategories> >(postCatDtos);
resultAddPostCat = await _postInCategoryRepository.AddBulk(postCatInputs);
}
// add tags
var tagIds = await getTagIdFromNames(postDto);
var resultAddPostTag = "Fail";
if (tagIds.Count > 0)
{
foreach (var tagId in tagIds)
{
postTagDtos.Add(new PostInTagsDto()
{
PostId = postId,
TagId = tagId,
});
}
var postTagInputs = _mapper.Map <List <PostInTags> >(postTagDtos);
resultAddPostTag = await _postInTagRepository.AddBulk(postTagInputs);
}
return(resultAddPostCat);
}
async Task <List <int> > getTagIdFromNames(PostsDto postDto)
{
var tagNames = postDto.tagNames;
// get tag already
string sqlGetTag = $"Name IN ('{string.Join("','", tagNames)}')";
var alreadyTags = await _tagRepository.GetList(sqlGetTag);
var alreadyTagNames = alreadyTags.Select(t => t.Name).ToList();
// get new tag
var newTagsNames = tagNames.Except(alreadyTagNames).ToList();
var newTagIds = new List <int>();
if (newTagsNames.Count > 0)
{
var tagDtos = new List <TagsDto>();
foreach (var nt in newTagsNames)
{
tagDtos.Add(new TagsDto()
{
Name = nt
});
}
var inputTags = _mapper.Map <List <Tags> >(tagDtos);
var tagAdds = await _tagRepository.AddBulk(inputTags);
newTagIds = tagAdds.Split(",").Select(t => Convert.ToInt32(t)).ToList();
}
// join 2 list id tag
var alreadyTagIds = alreadyTags.Select(t => t.Id).ToList();
var result = alreadyTagIds.Concat(newTagIds).ToList();
return(result);
}
public ServiceResponse <PostsDto> Update(PostsDto postsDto)
{
return(_postService.Update(postsDto));
}
public ServiceResponse <PostsDto> Insert(PostsDto postsDto)
{
return(_postService.Insert(postsDto));
}
public async Task <ResponseDto> Update(int postId, [FromBody] PostsDto postsDto)
{
return(await this.postsService.UpdatePost(postId, postsDto));
}
public async Task <ResponseDto> Create([FromBody] PostsDto postsDto)
{
return(await this.postsService.CreatePost(postsDto));
}
