public async Task <BlogGrpcResponse> DeleteTagAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            await _blogFileService.DeleteBlogTagAsync(request.TagId);

            var posts = await _blogFileService.GetBlogPostsAsync();

            foreach (var blogPost in posts)
            {
                if (blogPost.Tag.Contains(request.TagId))
                {
                    blogPost.Tag.Remove(request.TagId);
                    await _blogFileService.UpdateBlogPostAsync(blogPost, blogPost.Link);
                }
            }

            await _blogSiteHttpClient.ReloadBlogDataAsync();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(DeleteTagAsync)} failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> GetTagAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            var tag = await _blogFileService.GetBlogTagAsync(request.TagId);

            if (tag == null)
            {
                response.IsOk    = false;
                response.Message = $"Tag id = {request.TagId} not found.";
            }
            else
            {
                response.Tag = tag;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(GetTagAsync)} failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> GetPostsAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            var posts = await _blogFileService.GetBlogPostsAsync();

            var result = new List <BlogPostRuntime>();
            foreach (var blogPost in posts)
            {
                var blogPostRuntime = await GetBlogPostRuntimeAsync(blogPost, request.ExtractRuntime);

                result.Add(blogPostRuntime);
            }

            response.Posts = result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(GetPostsAsync)} failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> GetPostAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            var post = await _blogFileService.GetBlogPostAsync(request.Link);

            if (post == null)
            {
                response.IsOk    = false;
                response.Message = $"Post with link not found: {request.Link}";
            }
            else
            {
                var blogPostRuntime = await GetBlogPostRuntimeAsync(post, request.ExtractRuntime);

                response.PostRuntime = blogPostRuntime;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(GetPostAsync)}({request.Link}) failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> AddPostAccessAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            await _blogFileService.AddBlogPostAccessAsync(request.Link, DateTime.Now, 1);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(AddPostAccessAsync)}({request.Link}) failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> GetTagsAsync(CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            var tags = await _blogFileService.GetBlogTagsAsync();

            response.Tags = tags;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(GetTagsAsync)} failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> AddTagAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            await _blogFileService.AddBlogTagAsync(request.Tag);

            await _blogSiteHttpClient.ReloadBlogDataAsync();

            response.Tag = request.Tag;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(AddTagAsync)} failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }
    public async Task <BlogGrpcResponse> UpdatePostAsync(BlogGrpcRequest request, CallContext context = default)
    {
        var response = new BlogGrpcResponse();

        try
        {
            await _blogFileService.UpdateBlogPostAsync(request.Post, request.OriginalPostLink);

            await _blogSiteHttpClient.ReloadBlogDataAsync();

            response.Post = request.Post;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"{nameof(UpdatePostAsync)}({JsonUtil.Serialize(request.Post)}) failed.");
            response.IsOk    = false;
            response.Message = ex.Message;
        }

        return(response);
    }