AZEN-SGG/Kavita
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed some dead code on the interfaces. Introduced UnitOfWork to simplify repo injection.

Browse source
This commit is contained in:
Joseph Milazzo 2021-01-18 13:07:48 -06:00
parent 4a2296a18a
commit 825afd83a2
23 changed files with 165 additions and 204 deletions
Download patch file Download diff file Expand all files Collapse all files

16
API/Controllers/AccountController.cs
View file

@ -17,20 +17,20 @@ namespace API.Controllers
private readonly UserManager<AppUser> _userManager;
private readonly SignInManager<AppUser> _signInManager;
private readonly ITokenService _tokenService;
private readonly IUserRepository _userRepository;
private readonly IUnitOfWork _unitOfWork;
private readonly ILogger<AccountController> _logger;
private readonly IMapper _mapper;
public AccountController(UserManager<AppUser> userManager,
SignInManager<AppUser> signInManager,
ITokenService tokenService, IUserRepository userRepository,
ITokenService tokenService, IUnitOfWork unitOfWork,
ILogger<AccountController> logger,
IMapper mapper)
{
_userManager = userManager;
_signInManager = signInManager;
_tokenService = tokenService;
_userRepository = userRepository;
_unitOfWork = unitOfWork;
_logger = logger;
_mapper = mapper;
}
@ -38,7 +38,6 @@ namespace API.Controllers
[HttpPost("register")]
public async Task<ActionResult<UserDto>> Register(RegisterDto registerDto)
{
if (await _userManager.Users.AnyAsync(x => x.UserName == registerDto.Username))
{
return BadRequest("Username is taken.");
@ -77,8 +76,8 @@ namespace API.Controllers
// Update LastActive on account
user.LastActive = DateTime.Now;
_userRepository.Update(user);
await _userRepository.SaveAllAsync();
_unitOfWork.UserRepository.Update(user);
await _unitOfWork.Complete();
_logger.LogInformation($"{user.UserName} logged in at {user.LastActive}");
@ -88,10 +87,5 @@ namespace API.Controllers
Token = await _tokenService.CreateToken(user)
};
}
// private async Task<bool> UserExists(string username)
// {
// return await _userManager.Users.AnyAsync(user => user.UserName == username.ToLower());
// }
}
}

55
API/Controllers/LibraryController.cs
View file

@ -18,25 +18,21 @@ namespace API.Controllers
public class LibraryController : BaseApiController
{
private readonly IDirectoryService _directoryService;
private readonly ILibraryRepository _libraryRepository;
private readonly ILogger<LibraryController> _logger;
private readonly IUserRepository _userRepository;
private readonly IMapper _mapper;
private readonly ITaskScheduler _taskScheduler;
private readonly ISeriesRepository _seriesRepository;
private readonly IUnitOfWork _unitOfWork;
private readonly ICacheService _cacheService;
public LibraryController(IDirectoryService directoryService,
ILibraryRepository libraryRepository, ILogger<LibraryController> logger, IUserRepository userRepository,
IMapper mapper, ITaskScheduler taskScheduler, ISeriesRepository seriesRepository, ICacheService cacheService)
ILogger<LibraryController> logger, IMapper mapper, ITaskScheduler taskScheduler,
IUnitOfWork unitOfWork, ICacheService cacheService)
{
_directoryService = directoryService;
_libraryRepository = libraryRepository;
_logger = logger;
_userRepository = userRepository;
_mapper = mapper;
_taskScheduler = taskScheduler;
_seriesRepository = seriesRepository;
_unitOfWork = unitOfWork;
_cacheService = cacheService;
}
@ -49,12 +45,12 @@ namespace API.Controllers
[HttpPost("create")]
public async Task<ActionResult> AddLibrary(CreateLibraryDto createLibraryDto)
{
if (await _libraryRepository.LibraryExists(createLibraryDto.Name))
if (await _unitOfWork.LibraryRepository.LibraryExists(createLibraryDto.Name))
{
return BadRequest("Library name already exists. Please choose a unique name to the server.");
}
var admins = (await _userRepository.GetAdminUsersAsync()).ToList();
var admins = (await _unitOfWork.UserRepository.GetAdminUsersAsync()).ToList();
var library = new Library
{
@ -72,15 +68,16 @@ namespace API.Controllers
}
if (await _userRepository.SaveAllAsync())
if (!await _unitOfWork.Complete())
{
_logger.LogInformation($"Created a new library: {library.Name}");
var createdLibrary = await _libraryRepository.GetLibraryForNameAsync(library.Name);
BackgroundJob.Enqueue(() => _directoryService.ScanLibrary(createdLibrary.Id, false));
return Ok();
return BadRequest("There was a critical issue. Please try again.");
}
return BadRequest("There was a critical issue. Please try again.");
_logger.LogInformation($"Created a new library: {library.Name}");
var createdLibrary = await _unitOfWork.LibraryRepository.GetLibraryForNameAsync(library.Name);
BackgroundJob.Enqueue(() => _directoryService.ScanLibrary(createdLibrary.Id, false));
return Ok();
}
/// <summary>
@ -105,14 +102,14 @@ namespace API.Controllers
[HttpGet]
public async Task<ActionResult<IEnumerable<LibraryDto>>> GetLibraries()
{
return Ok(await _libraryRepository.GetLibrariesAsync());
return Ok(await _unitOfWork.LibraryRepository.GetLibrariesAsync());
}
[Authorize(Policy = "RequireAdminRole")]
[HttpPut("update-for")]
public async Task<ActionResult<MemberDto>> AddLibraryToUser(UpdateLibraryForUserDto updateLibraryForUserDto)
{
var user = await _userRepository.GetUserByUsernameAsync(updateLibraryForUserDto.Username);
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(updateLibraryForUserDto.Username);
if (user == null) return BadRequest("Could not validate user");
@ -123,7 +120,7 @@ namespace API.Controllers
user.Libraries.Add(_mapper.Map<Library>(selectedLibrary));
}
if (await _userRepository.SaveAllAsync())
if (await _unitOfWork.Complete())
{
_logger.LogInformation($"Added: {updateLibraryForUserDto.SelectedLibraries} to {updateLibraryForUserDto.Username}");
return Ok(user);
@ -143,7 +140,7 @@ namespace API.Controllers
[HttpGet("libraries-for")]
public async Task<ActionResult<IEnumerable<LibraryDto>>> GetLibrariesForUser(string username)
{
return Ok(await _libraryRepository.GetLibrariesDtoForUsernameAsync(username));
return Ok(await _unitOfWork.LibraryRepository.GetLibrariesDtoForUsernameAsync(username));
}
[HttpGet("series")]
@ -151,10 +148,10 @@ namespace API.Controllers
{
if (forUser)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
return Ok(await _seriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId, user.Id));
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
return Ok(await _unitOfWork.SeriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId, user.Id));
}
return Ok(await _seriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId));
return Ok(await _unitOfWork.SeriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId));
}
[Authorize(Policy = "RequireAdminRole")]
@ -163,10 +160,10 @@ namespace API.Controllers
{
var username = User.GetUsername();
_logger.LogInformation($"Library {libraryId} is being deleted by {username}.");
var series = await _seriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId);
var volumes = (await _seriesRepository.GetVolumesForSeriesAsync(series.Select(x => x.Id).ToArray()))
var series = await _unitOfWork.SeriesRepository.GetSeriesDtoForLibraryIdAsync(libraryId);
var volumes = (await _unitOfWork.SeriesRepository.GetVolumesForSeriesAsync(series.Select(x => x.Id).ToArray()))
.Select(x => x.Id).ToArray();
var result = await _libraryRepository.DeleteLibrary(libraryId);
var result = await _unitOfWork.LibraryRepository.DeleteLibrary(libraryId);
if (result && volumes.Any())
{
@ -180,7 +177,7 @@ namespace API.Controllers
[HttpPost("update")]
public async Task<ActionResult> UpdateLibrary(UpdateLibraryDto libraryForUserDto)
{
var library = await _libraryRepository.GetLibraryForIdAsync(libraryForUserDto.Id);
var library = await _unitOfWork.LibraryRepository.GetLibraryForIdAsync(libraryForUserDto.Id);
var originalFolders = library.Folders.Select(x => x.Path);
var differenceBetweenFolders = originalFolders.Except(libraryForUserDto.Folders);
@ -190,9 +187,9 @@ namespace API.Controllers
_libraryRepository.Update(library);
_unitOfWork.LibraryRepository.Update(library);
if (await _libraryRepository.SaveAllAsync())
if (await _unitOfWork.Complete())
{
if (differenceBetweenFolders.Any())
{

23
API/Controllers/ReaderController.cs
View file

@ -6,9 +6,7 @@ using API.DTOs;
using API.Entities;
using API.Extensions;
using API.Interfaces;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
namespace API.Controllers
@ -18,22 +16,15 @@ namespace API.Controllers
private readonly IDirectoryService _directoryService;
private readonly ICacheService _cacheService;
private readonly ILogger<ReaderController> _logger;
private readonly UserManager<AppUser> _userManager;
private readonly DataContext _dataContext; // TODO: Refactor code into repo
private readonly IUserRepository _userRepository;
private readonly ISeriesRepository _seriesRepository;
private readonly IUnitOfWork _unitOfWork;
public ReaderController(IDirectoryService directoryService, ICacheService cacheService,
ILogger<ReaderController> logger, UserManager<AppUser> userManager, DataContext dataContext,
IUserRepository userRepository, ISeriesRepository seriesRepository)
ILogger<ReaderController> logger, IUnitOfWork unitOfWork)
{
_directoryService = directoryService;
_cacheService = cacheService;
_logger = logger;
_userManager = userManager;
_dataContext = dataContext;
_userRepository = userRepository;
_seriesRepository = seriesRepository;
_unitOfWork = unitOfWork;
}
[HttpGet("image")]
@ -52,7 +43,7 @@ namespace API.Controllers
[HttpGet("get-bookmark")]
public async Task<ActionResult<int>> GetBookmark(int volumeId)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
if (user.Progresses == null) return Ok(0);
var progress = user.Progresses.SingleOrDefault(x => x.AppUserId == user.Id && x.VolumeId == volumeId);
@ -64,7 +55,7 @@ namespace API.Controllers
[HttpPost("bookmark")]
public async Task<ActionResult> Bookmark(BookmarkDto bookmarkDto)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
_logger.LogInformation($"Saving {user.UserName} progress for {bookmarkDto.VolumeId} to page {bookmarkDto.PageNum}");
user.Progresses ??= new List<AppUserProgress>();
@ -87,9 +78,9 @@ namespace API.Controllers
}
_userRepository.Update(user);
_unitOfWork.UserRepository.Update(user);
if (await _userRepository.SaveAllAsync())
if (await _unitOfWork.Complete())
{
return Ok();
}

27
API/Controllers/SeriesController.cs
View file

@ -15,28 +15,23 @@ namespace API.Controllers
public class SeriesController : BaseApiController
{
private readonly ILogger<SeriesController> _logger;
private readonly IMapper _mapper;
private readonly ITaskScheduler _taskScheduler;
private readonly ISeriesRepository _seriesRepository;
private readonly ICacheService _cacheService;
private readonly IUserRepository _userRepository;
private readonly IUnitOfWork _unitOfWork;
public SeriesController(ILogger<SeriesController> logger, IMapper mapper,
ITaskScheduler taskScheduler, ISeriesRepository seriesRepository,
ICacheService cacheService, IUserRepository userRepository)
public SeriesController(ILogger<SeriesController> logger, ITaskScheduler taskScheduler,
ICacheService cacheService, IUnitOfWork unitOfWork)
{
_logger = logger;
_mapper = mapper;
_taskScheduler = taskScheduler;
_seriesRepository = seriesRepository;
_cacheService = cacheService;
_userRepository = userRepository;
_unitOfWork = unitOfWork;
}
[HttpGet("{seriesId}")]
public async Task<ActionResult<SeriesDto>> GetSeries(int seriesId)
{
return Ok(await _seriesRepository.GetSeriesDtoByIdAsync(seriesId));
return Ok(await _unitOfWork.SeriesRepository.GetSeriesDtoByIdAsync(seriesId));
}
[Authorize(Policy = "RequireAdminRole")]
@ -44,9 +39,9 @@ namespace API.Controllers
public async Task<ActionResult<bool>> DeleteSeries(int seriesId)
{
var username = User.GetUsername();
var volumes = (await _seriesRepository.GetVolumesForSeriesAsync(new []{seriesId})).Select(x => x.Id).ToArray();
var volumes = (await _unitOfWork.SeriesRepository.GetVolumesForSeriesAsync(new []{seriesId})).Select(x => x.Id).ToArray();
_logger.LogInformation($"Series {seriesId} is being deleted by {username}.");
var result = await _seriesRepository.DeleteSeriesAsync(seriesId);
var result = await _unitOfWork.SeriesRepository.DeleteSeriesAsync(seriesId);
if (result)
{
@ -60,16 +55,16 @@ namespace API.Controllers
{
if (forUser)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
return Ok(await _seriesRepository.GetVolumesDtoAsync(seriesId, user.Id));
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
return Ok(await _unitOfWork.SeriesRepository.GetVolumesDtoAsync(seriesId, user.Id));
}
return Ok(await _seriesRepository.GetVolumesDtoAsync(seriesId)); // TODO: Refactor out forUser = false since everything is user based
return Ok(await _unitOfWork.SeriesRepository.GetVolumesDtoAsync(seriesId)); // TODO: Refactor out forUser = false since everything is user based
}
[HttpGet("volume")]
public async Task<ActionResult<VolumeDto>> GetVolume(int volumeId)
{
return Ok(await _seriesRepository.GetVolumeDtoAsync(volumeId));
return Ok(await _unitOfWork.SeriesRepository.GetVolumeDtoAsync(volumeId));
}
}
}

20
API/Controllers/UsersController.cs
View file

@ -12,23 +12,21 @@ namespace API.Controllers
[Authorize]
public class UsersController : BaseApiController
{
private readonly IUserRepository _userRepository;
private readonly ILibraryRepository _libraryRepository;
private readonly IUnitOfWork _unitOfWork;
public UsersController(IUserRepository userRepository, ILibraryRepository libraryRepository)
public UsersController(IUnitOfWork unitOfWork)
{
_userRepository = userRepository;
_libraryRepository = libraryRepository;
_unitOfWork = unitOfWork;
}
[Authorize(Policy = "RequireAdminRole")]
[HttpDelete("delete-user")]
public async Task<ActionResult> DeleteUser(string username)
{
var user = await _userRepository.GetUserByUsernameAsync(username);
_userRepository.Delete(user);
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username);
_unitOfWork.UserRepository.Delete(user);
if (await _userRepository.SaveAllAsync())
if (await _unitOfWork.Complete())
{
return Ok();
}
@ -40,7 +38,7 @@ namespace API.Controllers
[HttpGet]
public async Task<ActionResult<IEnumerable<MemberDto>>> GetUsers()
{
return Ok(await _userRepository.GetMembersAsync());
return Ok(await _unitOfWork.UserRepository.GetMembersAsync());
}
[HttpGet("has-library-access")]
@ -48,11 +46,11 @@ namespace API.Controllers
{
// TODO: refactor this to use either userexists or usermanager
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
var user = await _unitOfWork.UserRepository.GetUserByUsernameAsync(User.GetUsername());
if (user == null) return BadRequest("Could not validate user");
var libs = await _libraryRepository.GetLibrariesDtoForUsernameAsync(user.UserName);
var libs = await _unitOfWork.LibraryRepository.GetLibrariesDtoForUsernameAsync(user.UserName);
return Ok(libs.Any(x => x.Id == libraryId));
}