Note Onion - 3 - Infrastructure - NoteRepository

Here is the source code for NoteRepository.cs file it is placed in the Repositories directory of the Note.Infrastructure project.

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Note.Domain.Entities;
using Note.Domain.Repositories;
using Note.Infrastructure.Data;
using Note.Shared;

namespace Note.Infrastructure.Repositories
{
    public class NoteRepository : BaseRepository<NoteRepository>, INoteRepository
    {
        private readonly NoteDataContext _dbContext;

        public NoteRepository(NoteDataContext dbContext, 
                                ILogger<NoteRepository> logger) : base(logger)
        {
            _dbContext = dbContext;
        }

        public async Task<IResult<List<NoteEntity>>> GetAllNotes(
            string companyKey, 
            string applicationKey, 
            string applicationSubKey)
        {
            try
            {
                //return await Task<IResult<List<NoteEntity>>>(
                //      _dbContext.Notes
                //                .Where(n => n.CompanyKey == companyKey && 
                //                            n.ApplicationKey == applicationKey && 
                //                            n.ApplicationSubKey == applicationSubKey)
                //                .Include(n => n.NoteTypeEntity)
                //                .ToListAsync()
                //    ).ReturnSuccess(LogInformation("Retrieved all Notes records successfully"));

                var dbEntity = await _dbContext.Notes
                                .Where(n => n.CompanyKey == companyKey &&
                                            n.ApplicationKey == applicationKey &&
                                            n.ApplicationSubKey == applicationSubKey)
                                .Include(n => n.NoteTypeEntity)
                                .ToListAsync();

                if (dbEntity == null)
                    return new Result<List<NoteEntity>>().ReturnFail(LogWarning("Notes Not Found"));
                
                return new Result<List<NoteEntity>>(dbEntity).ReturnSuccess(LogInformation("Obtained Notes recordset"));
            }
            catch (Exception e)
            {
                return new Result<List<NoteEntity>>().ReturnFail(e.Message, 0);
            }
        }

        public async Task<IResult<NoteEntity>> GetNoteById(string companyKey, long id)
        {
            if (id < 0)
                return new Result<NoteEntity>().ReturnFail(LogWarning("Invalid Id"), id);
            try
            {
                var dbEntity = _dbContext.Notes
                                         .Include(r => r.NoteTypeEntity)
                                         .FirstOrDefault(e => e.Id == id);

                if (dbEntity == null)
                    return new Result<NoteEntity>().ReturnFail(LogWarning("Note Not Found"));
                
                return new Result<NoteEntity>(dbEntity).ReturnSuccess(LogInformation("Obtained Note record"));
            }
            catch (Exception ex)
            {
                return new Result<NoteEntity>().ReturnFail(LogError("Error trying to retrieve Note", ex), id);
            }
        }

        public async Task<IBaseResult> CreateNote(NoteEntity noteEntity)
        {
            try
            {
                _dbContext.Add(noteEntity);
                _dbContext.Entry(noteEntity).State = EntityState.Added;
                _dbContext.Entry(noteEntity.NoteTypeEntity).State = EntityState.Unchanged;

                var numUpdated =  _dbContext.SaveChanges();
                if (numUpdated > 0)
                    return new Result().ReturnSuccess(LogInformation("Note added Successfully"));
                
                return new Result().ReturnFail(LogError("Error adding Note"));
            }
            catch (Exception ex)
            {
                return new Result().ReturnFail(LogError("Error adding Note!", ex), noteEntity.Id);
            }
        }

        public async Task<IBaseResult> UpdateNote(NoteEntity noteEntity)
        {
            //_dbContext.Entry(note).State = EntityState.Modified;
            //await _dbContext.SaveChangesAsync();
            try
            {
                noteEntity.NoteTypeId = noteEntity.NoteTypeEntity.Id;
                _dbContext.Notes.Update(noteEntity);
                //_dbContext.Entry(noteEntity).State = EntityState.Modified;
                _dbContext.Entry(noteEntity.NoteTypeEntity).State = EntityState.Unchanged;
                //_context.Entry(noteEntity.IdEntity).State = EntityState.Unchanged;

                if (_dbContext.SaveChanges() > 0)
                    return new Result().ReturnSuccess(LogInformation("Updated Note record"));
                
                return new Result().ReturnFail(LogError("Error updating Note record"), noteEntity.Id);
            }
            catch (Exception ex)
            {
                return new Result().ReturnFail(LogError("Error updating Note record!", ex), noteEntity.Id);
            }
        }

        public async Task<IBaseResult> DeleteNote(string companyKey, long id)
        {
            //var note = await _dbContext.Notes.FindAsync(id);
            //if (note != null)
            //{
            //    _dbContext.Notes.Remove(note);
            //    await _dbContext.SaveChangesAsync();
            //}

            try
            {
                var noteEntity = await GetNoteById(companyKey, id);

                _dbContext.Notes.Remove(noteEntity.Model);
                var saveResults = _dbContext.SaveChanges();
                if (saveResults > 0)
                {
                    return new Result().ReturnSuccess(LogInformation("Deleted Note record"));

                    //var logResult = await LogInformation("Deleted Note record");
                    //return new Result().ReturnSuccess(logResult);
                }
                    
                
                return new Result().ReturnFail(LogError("Error deleting Note record"), noteEntity.Model.Id);
            }
            catch (Exception ex)
            {
                return new Result().ReturnFail(LogError("Error deleting Note record!", ex), id);
            }

        }
    }
}