ElasticSearch ile aksyion loglama

public abstract class ElasticSearchService<T> : IElasticSearchService<T> where T : BaseEntity
{
    private readonly ElasticClient _client;
    public ElasticSearchService(ElasticClientProvider provider)
    {
        _client = provider.ElasticClient;
    }

    public void CheckIndexExist(T logModel, string indexName)
    {
        var response = _client.Indices.Exists(indexName);
        if (!response.Exists)
        {
            _client.Indices.Create(indexName,
                 index => index.Map<T>(
                      x => x
                     .AutoMap()
              ));
        }

    }

    public IEnumerable<T> All(string indexName)
    {
        return _client.Search<T>(search =>
            search.From(0).Size(1000).MatchAll().Index(indexName)).Documents;
    }


    public bool Delete(Guid id)
    {
        throw new NotImplementedException();
    }

    public T Get(Guid id, string indexName)
    {
        var getResponse = _client.Get<T>(id, g => g.Index(indexName));

        return getResponse.Source;
    }

    public IndexResponse Save(T entity, string indexName)
    {
        CheckIndexExist(entity, indexName);

        var result = _client.Index<T>(entity, idx => idx.Index(indexName));
        return result;
    }
}

public IActionResult FillDataFromJsonToElastic()
{
    var books = new List<BookJsonModel>();

    using (StreamReader r = new StreamReader("books_new.json"))
    {
        string json = r.ReadToEnd();
        books = JsonConvert.DeserializeObject<List<BookJsonModel>>(json);
    }

    foreach (var item in books)
    {
        var bookModel = new Book(){
            Id = Guid.NewGuid(),
            Title = item.Title,
            Author = BookHelper.TitleNameSurname(item.Author),
            Genre = BookHelper.GenreUpperCase(item.Genre),
            SubGenre = BookHelper.GenreUpperCase(item.SubGenre),
            Publisher = item.Publisher,
            Page = item.Height
        };   

        var response = _bookService.Save(bookModel, _bookIndexName);
        if (!response.IsValid)
        {
            throw new Exception(response.OriginalException.Message);
        }   

    }

    var booksElastic = _bookService.All(_bookIndexName);
    return Json(booksElastic);
}

public class BooksController : Controller
{
    private string _bookIndexName;
    private string _userBookIndexName;
    private readonly BookService _bookService;
    private readonly UserBookService _userBookService;

    public BooksController(BookService bookService, UserBookService userBookService, IOptions<ElasticConnectionSettings> elasticConnection)
    {
        _bookService = bookService;
        _userBookService = userBookService;
        _bookIndexName = elasticConnection.Value.ElasticBookIndex;
        _userBookIndexName = elasticConnection.Value.ElasticUserBookIndex;
    }

    public IActionResult Index()
    {
        var books = _bookService.All(_bookIndexName);
        return View(books);
    }
}

[Authorize]
public IActionResult Detail(Guid id)
{
    var book = _bookService.Get(id, _bookIndexName);
    var userBooks = _userBookService.SearchUserBooks(_userBookIndexName,User.Identity.Name).ToList();
    ViewData["AddedLibrary"] = userBooks.Any(s => s.Action == "AddMyLibrary" && s.BookTitle == book.Title) ? "1" : "0";

    if (book != null)
    {
        var userBookModel = new UserBookModel(){
            Id = Guid.NewGuid(),
            UserName = User.Identity.Name,
            BookTitle = book.Title,
            BookCategory = book.Genre,
            BookSubCategory = book.SubGenre,
            BookAuthor = book.Author,
            Action = "Detail",
            ActionDate = DateTime.Now
        };

        var response = _userBookService.Save(userBookModel, _userBookIndexName);
        if (!response.IsValid)
        {
            throw new Exception(response.OriginalException.Message);
        }

    }

    return View(book);
}

[HttpPost]
[Route("addMyLibrary")]
public JsonResult AddMyLibrary(Guid bookId)
{
    AjaxResult result = new AjaxResult();

    var book = _bookService.Get(bookId, _bookIndexName);

    var userBookModel = new UserBookModel(){
        Id = Guid.NewGuid(),
        UserName = User.Identity.Name,
        BookTitle = book.Title,
        BookCategory = book.Genre,
        BookSubCategory = book.SubGenre,
        BookAuthor = book.Author,
        Action = "AddMyLibrary",
        ActionDate = DateTime.Now
    };

    var response = _userBookService.Save(userBookModel, _userBookIndexName);
    if (!response.IsValid)
    {
        result.IsSuccess = false;
        result.Message = response.OriginalException.Message;
    }
    else
    {
        result.IsSuccess = true;
        result.Message = "Added Your Library";
    }

    return Json(result);
}

public IReadOnlyCollection<UserBookModel> SearchUserBooks(string indexName, string userName)
{
    var response = _client.Search<UserBookModel>(s => s
                    .Index(indexName)
                    .From(0)
                    .Size(1000)
                    .Sort(st => st.Descending(p => p.ActionDate))
                    .Query(q => q.Match(m => m.Field(f => f.UserName).Query(userName)))

    );
    return response.Documents;
}