public async Task <CustomApiResponse> Put([FromBody] TagsDto entity)
{
var inputEntity = _mapper.Map <Tags>(entity);
var result = await _tagService.Update(inputEntity);
return(new CustomApiResponse(entity.Id, result ? "Succeeded" : "Failed", !result));
}
public static Tags Convert(TagsDto tag)
{
return(new Tags
{
Id = tag.Id,
Name = tag.Name
});
}
public async Task <TagsDto> CreateAsync(TagsDto item)
{
var tag = _context.Tags.Add(
TagConverter.Convert(item));
await _context.SaveChangesAsync();
return(TagConverter.Convert(tag.Entity));
}
public async Task <bool> UpdateAsync(TagsDto item)
{
if (item == null)
{
return(false);
}
_context.Tags.Update(TagConverter.Convert(item));
await _context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Put([FromBody] TagsDto item)
{
try
{
return(Ok(await _repository.UpdateAsync(item)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public async Task <CustomApiResponse> Post([FromBody] TagsDto entity)
{
var inputEntity = _mapper.Map <Tags>(entity);
if (await _tagService.IsExisted(entity.Name))
{
return(new CustomApiResponse("TagName đã tồn tại", true));
}
var result = await _tagService.Add(inputEntity);
return(new CustomApiResponse(result));
}
public IActionResult AddTag([FromBody] TagsDto model)
{
try
{
using (var tagsRepo = new TagRepository())
{
var results = tagsRepo.Insert(model);
return(Ok(results));
}
}
catch (Exception ex)
{
return(NotFound(ex));
}
}
public async Task <Response <TagsDto> > GetTags(TagsQuery request)
{
var result = _context.Tags.AsQueryable();
if (!string.IsNullOrEmpty(request.Title))
{
result = result.Where(x => x.Title.Contains(request.Title));
}
///pagenating
int take = request.PageSize;
int skip = (request.PageId - 1) * take;
int totalPages = (int)Math.Ceiling(result.Count() / (double)take);
var finalResult = result.OrderBy(x => x.Title).Skip(skip).Take(take).AsQueryable();
//----------------
var resultData = new TagsDto
{
Dtos = await finalResult.Select(d => new TagDto()
{
Id = d.Id,
Title = d.Title
}).ToListAsync(),
PageId = request.PageId,
PageSize = request.PageSize,
Total = await result.CountAsync()
};
return(new Response <TagsDto>
{
Data = resultData,
Status = true,
Message = "success"
});
}
public async Task <TagsDto> GetTagsByTagNameAndDate(string tag, DateTime date)
{
if (tag == null || date == default(DateTime))
{
return(null);
}
var normalisedTag = TagNormaliser.Normalise(tag);
var articles = _articlesContext.Articles
.Where(x => x.Tags.Any(y => y == normalisedTag) && x.Date.Date == date.Date).ToList();
if (!articles.Any())
{
return(null);
}
// rather big linq statement -> select tags lists from each article and flatten
var relatedTags = articles
.SelectMany(x => x.Tags)
// Remove present tag
.Where(x => x != normalisedTag)
// deduplicate
.ToHashSet();
var tagDto = new TagsDto
{
Tag = normalisedTag,
// take a maximum of 10 articles
Articles = articles.Select(x => x.Id).Take(10).ToArray(),
// Get total related tags for the day
Count = articles.SelectMany(x => x.Tags).Count(),
RelatedTags = relatedTags.ToArray()
};
return(tagDto);
}
public async Task <IActionResult> CreateTag([FromBody] TagsDto dto)
{
var response = await Mediator.Send(new CreateTagRequest { dto = dto });
return(Ok(response));
}
public void ReplaceTags(string id, TagsDto tagsDto)
{
var build = ById(id);
build.Tags = tagsDto;
}
