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

Tweaks (#1890)

Browse source 
* Updated number inputs with a more mobile friendly control

* Started writing lots of unit tests on PersonHelper to try and hammer out foreign constraint

* Fixes side-nav actionable alignment

* Added some unit tests

* Buffed out the unit tests

* Applied input modes throughout the app

* Fixed a small bug in refresh token validation to make it work correctly

* Try out a new way to block multithreading from interacting with people during series metadata update.

* Fixed the lock code to properly lock, which should help with any constraint issues.

* Locking notes

* Tweaked locking on people to prevent a constraint issue. This slows down the scanner a bit, but not much. Will tweak after validating on a user's server.

* Replaced all DBFactory.Series with SeriesBuilder.

* Replaced all DBFactory.Volume() with VolumeBuilder

* Replaced SeriesMetadata with Builder

* Replaced DBFactory.CollectionTag

* Lots of refactoring to streamline entity creation

* Fixed one of the unit tests

* Refactored all of new Library()

* Removed tag and genre

* Removed new SeriesMetadata

* Refactored new Volume()

* MangaFile()

* ReadingList()

* Refactored all of Chapter and ReadingList

* Add title to all event widget flows

* Updated Base Url to inform user it doesn't work for docker users with non-root user.

* Added unit test coverage to FormatChapterTitle and FormatChapterName.

* Started on Unit test for scanner, but need to finish it later.

---------

Co-authored-by: Robbie Davis <robbie@therobbiedavis.com>
This commit is contained in:
Joe Milazzo 2023-03-19 12:52:44 -05:00 • committed by GitHub
parent eec03d7e96
commit 385f61f9f0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
105 changed files with 2257 additions and 2660 deletions
Download patch file Download diff file Expand all files Collapse all files

18
API/Controllers/AccountController.cs
View file

@ -13,6 +13,7 @@ using API.Entities;
using API.Entities.Enums;
using API.Errors;
using API.Extensions;
using API.Helpers.Builders;
using API.Middleware.RateLimit;
using API.Services;
using API.SignalR;
@ -126,16 +127,9 @@ public class AccountController : BaseApiController
return BadRequest(usernameValidation);
}
var user = new AppUser()
{
UserName = registerDto.Username,
Email = registerDto.Email,
UserPreferences = new AppUserPreferences
{
Theme = await _unitOfWork.SiteThemeRepository.GetDefaultTheme()
},
ApiKey = HashUtil.ApiKey()
};
var user = new AppUserBuilder(registerDto.Username, registerDto.Email,
await _unitOfWork.SiteThemeRepository.GetDefaultTheme()).Build();
var result = await _userManager.CreateAsync(user, registerDto.Password);
if (!result.Succeeded) return BadRequest(result.Errors);
@ -204,6 +198,8 @@ public class AccountController : BaseApiController
// Update LastActive on account
user.UpdateLastActive();
// NOTE: This can likely be removed
user.UserPreferences ??= new AppUserPreferences
{
Theme = await _unitOfWork.SiteThemeRepository.GetDefaultTheme()
@ -537,7 +533,7 @@ public class AccountController : BaseApiController
}
// Create a new user
var user = DbFactory.AppUser(dto.Email, dto.Email, await _unitOfWork.SiteThemeRepository.GetDefaultTheme());
var user = new AppUserBuilder(dto.Email, dto.Email, await _unitOfWork.SiteThemeRepository.GetDefaultTheme()).Build();
try
{

6
API/Controllers/ReaderController.cs
View file

@ -34,14 +34,12 @@ public class ReaderController : BaseApiController
private readonly IBookmarkService _bookmarkService;
private readonly IAccountService _accountService;
private readonly IEventHub _eventHub;
private readonly IImageService _imageService;
private readonly IDirectoryService _directoryService;
/// <inheritdoc />
public ReaderController(ICacheService cacheService,
IUnitOfWork unitOfWork, ILogger<ReaderController> logger,
IReaderService readerService, IBookmarkService bookmarkService,
IAccountService accountService, IEventHub eventHub, IImageService imageService, IDirectoryService directoryService)
IAccountService accountService, IEventHub eventHub)
{
_cacheService = cacheService;
_unitOfWork = unitOfWork;
@ -50,8 +48,6 @@ public class ReaderController : BaseApiController
_bookmarkService = bookmarkService;
_accountService = accountService;
_eventHub = eventHub;
_imageService = imageService;
_directoryService = directoryService;
}
/// <summary>

2
API/Controllers/UploadController.cs
View file

@ -229,7 +229,7 @@ public class UploadController : BaseApiController
}
return _imageService.CreateThumbnailFromBase64(uploadFileDto.Url,
filename, convertToWebP); ;
filename, convertToWebP);
}
/// <summary>

198
API/Data/DbFactory.cs
View file

@ -1,198 +0,0 @@
using System.Collections.Generic;
using System.IO;
using API.Entities;
using API.Entities.Enums;
using API.Entities.Metadata;
using API.Extensions;
using API.Parser;
using API.Services.Tasks;
using Kavita.Common;
namespace API.Data;
/// <summary>
/// Responsible for creating Series, Volume, Chapter, MangaFiles for use in <see cref="ScannerService"/>
/// </summary>
public static class DbFactory
{
public static Library Library(string name, LibraryType type)
{
return new Library()
{
Name = name,
Type = type,
Series = new List<Series>(),
Folders = new List<FolderPath>(),
AppUsers = new List<AppUser>()
};
}
public static Series Series(string name)
{
return new Series
{
Name = name,
OriginalName = name,
LocalizedName = name,
NormalizedName = name.ToNormalized(),
NormalizedLocalizedName = name.ToNormalized(),
SortName = name,
Volumes = new List<Volume>(),
Metadata = SeriesMetadata(new List<CollectionTag>())
};
}
public static Series Series(string name, string localizedName)
{
if (string.IsNullOrEmpty(localizedName))
{
localizedName = name;
}
return new Series
{
Name = name,
OriginalName = name,
LocalizedName = localizedName,
NormalizedName = name.ToNormalized(),
NormalizedLocalizedName = localizedName.ToNormalized(),
SortName = name,
Volumes = new List<Volume>(),
Metadata = SeriesMetadata(new List<CollectionTag>())
};
}
public static Volume Volume(string volumeNumber)
{
return new Volume()
{
Name = volumeNumber,
Number = (int) Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(volumeNumber),
Chapters = new List<Chapter>()
};
}
public static Chapter Chapter(ParserInfo info)
{
var specialTreatment = info.IsSpecialInfo();
var specialTitle = specialTreatment ? info.Filename : info.Chapters;
return new Chapter()
{
Number = specialTreatment ? "0" : Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(info.Chapters) + string.Empty,
Range = specialTreatment ? info.Filename : info.Chapters,
Title = (specialTreatment && info.Format == MangaFormat.Epub)
? info.Title
: specialTitle,
Files = new List<MangaFile>(),
IsSpecial = specialTreatment,
};
}
public static SeriesMetadata SeriesMetadata(ICollection<CollectionTag> collectionTags)
{
return new SeriesMetadata()
{
CollectionTags = collectionTags,
Summary = string.Empty
};
}
public static CollectionTag CollectionTag(int id, string title, string? summary = null, bool promoted = false)
{
title = title.Trim();
return new CollectionTag()
{
Id = id,
NormalizedTitle = title.ToNormalized(),
Title = title,
Summary = summary?.Trim(),
Promoted = promoted,
SeriesMetadatas = new List<SeriesMetadata>()
};
}
public static ReadingList ReadingList(string title, string? summary = null, bool promoted = false, AgeRating rating = AgeRating.Unknown)
{
title = title.Trim();
return new ReadingList()
{
NormalizedTitle = title.ToNormalized(),
Title = title,
Summary = summary?.Trim(),
Promoted = promoted,
Items = new List<ReadingListItem>(),
AgeRating = rating
};
}
public static ReadingListItem ReadingListItem(int index, int seriesId, int volumeId, int chapterId)
{
return new ReadingListItem()
{
Order = index,
ChapterId = chapterId,
SeriesId = seriesId,
VolumeId = volumeId
};
}
public static Genre Genre(string name)
{
return new Genre()
{
Title = name.Trim().SentenceCase(),
NormalizedTitle = name.ToNormalized()
};
}
public static Tag Tag(string name)
{
return new Tag()
{
Title = name.Trim().SentenceCase(),
NormalizedTitle = name.ToNormalized()
};
}
public static Person Person(string name, PersonRole role)
{
return new Person()
{
Name = name.Trim(),
NormalizedName = name.ToNormalized(),
Role = role
};
}
public static MangaFile MangaFile(string filePath, MangaFormat format, int pages)
{
return new MangaFile()
{
FilePath = filePath,
Format = format,
Pages = pages,
LastModified = File.GetLastWriteTime(filePath),
LastModifiedUtc = File.GetLastWriteTimeUtc(filePath),
};
}
public static Device Device(string name)
{
return new Device()
{
Name = name,
};
}
public static AppUser AppUser(string username, string email, SiteTheme defaultTheme)
{
return new AppUser()
{
UserName = username,
Email = email,
ApiKey = HashUtil.ApiKey(),
UserPreferences = new AppUserPreferences
{
Theme = defaultTheme
}
};
}
}

1
API/Data/MigrateBrokenGMT1Dates.cs
View file

@ -9,6 +9,7 @@ namespace API.Data;
/// v0.7 introduced UTC dates and GMT+1 users would sometimes have dates stored as '0000-12-31 23:00:00'.
/// This Migration will update those dates.
/// </summary>
// ReSharper disable once InconsistentNaming
public static class MigrateBrokenGMT1Dates
{
public static async Task Migrate(IUnitOfWork unitOfWork, DataContext dataContext, ILogger<Program> logger)

2
API/Entities/Chapter.cs
View file

@ -2,7 +2,7 @@
using System.Collections.Generic;
using API.Entities.Enums;
using API.Entities.Interfaces;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
namespace API.Entities;

2
API/Extensions/ChapterListExtensions.cs
View file

@ -2,7 +2,7 @@ using System.Collections.Generic;
using System.Linq;
using API.Entities;
using API.Helpers;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
namespace API.Extensions;

2
API/Extensions/ParserInfoListExtensions.cs
View file

@ -1,7 +1,7 @@
using System.Collections.Generic;
using System.Linq;
using API.Entities;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
namespace API.Extensions;

40
API/Helpers/Builders/AppUserBuilder.cs Normal file
View file

@ -0,0 +1,40 @@
using System.Collections.Generic;
using System.Linq;
using API.Data;
using API.Entities;
using Kavita.Common;
namespace API.Helpers.Builders;
public class AppUserBuilder : IEntityBuilder<AppUser>
{
private readonly AppUser _appUser;
public AppUser Build() => _appUser;
public AppUserBuilder(string username, string email, SiteTheme? theme = null)
{
_appUser = new AppUser()
{
UserName = username,
Email = email,
ApiKey = HashUtil.ApiKey(),
UserPreferences = new AppUserPreferences
{
Theme = theme ?? Seed.DefaultThemes.First()
},
ReadingLists = new List<ReadingList>(),
Bookmarks = new List<AppUserBookmark>(),
Libraries = new List<Library>(),
Ratings = new List<AppUserRating>(),
Progresses = new List<AppUserProgress>(),
Devices = new List<Device>(),
Id = 0
};
}
public AppUserBuilder WithLibrary(Library library)
{
_appUser.Libraries.Add(library);
return this;
}
}

54
API/Helpers/Builders/ChapterBuilder.cs
View file

@ -2,6 +2,7 @@
using System.Collections.Generic;
using API.Entities;
using API.Entities.Enums;
using API.Services.Tasks.Scanner.Parser;
namespace API.Helpers.Builders;
@ -16,12 +17,43 @@ public class ChapterBuilder : IEntityBuilder<Chapter>
{
Range = string.IsNullOrEmpty(range) ? number : range,
Title = string.IsNullOrEmpty(range) ? number : range,
Number = API.Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(number) + string.Empty,
Number = Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(number) + string.Empty,
Files = new List<MangaFile>(),
Pages = 1
};
}
public static ChapterBuilder FromParserInfo(ParserInfo info)
{
var specialTreatment = info.IsSpecialInfo();
var specialTitle = specialTreatment ? info.Filename : info.Chapters;
var builder = new ChapterBuilder(Services.Tasks.Scanner.Parser.Parser.DefaultChapter);
return builder.WithNumber(specialTreatment ? Services.Tasks.Scanner.Parser.Parser.DefaultChapter : Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(info.Chapters) + string.Empty)
.WithRange(specialTreatment ? info.Filename : info.Chapters)
.WithTitle((specialTreatment && info.Format == MangaFormat.Epub)
? info.Title
: specialTitle)
.WithIsSpecial(specialTreatment);
}
public ChapterBuilder WithId(int id)
{
_chapter.Id = Math.Max(id, 0);
return this;
}
private ChapterBuilder WithNumber(string number)
{
_chapter.Number = number;
return this;
}
private ChapterBuilder WithRange(string range)
{
_chapter.Range = range;
return this;
}
public ChapterBuilder WithReleaseDate(DateTime time)
{
_chapter.ReleaseDate = time;
@ -61,4 +93,24 @@ public class ChapterBuilder : IEntityBuilder<Chapter>
_chapter.Files.Add(file);
return this;
}
public ChapterBuilder WithFiles(IList<MangaFile> files)
{
_chapter.Files = files ?? new List<MangaFile>();
return this;
}
public ChapterBuilder WithLastModified(DateTime lastModified)
{
_chapter.LastModified = lastModified;
_chapter.LastModifiedUtc = lastModified.ToUniversalTime();
return this;
}
public ChapterBuilder WithCreated(DateTime created)
{
_chapter.Created = created;
_chapter.CreatedUtc = created.ToUniversalTime();
return this;
}
}

57
API/Helpers/Builders/CollectionTagBuilder.cs Normal file
View file

@ -0,0 +1,57 @@
using System.Collections.Generic;
using API.Entities;
using API.Entities.Metadata;
using API.Extensions;
namespace API.Helpers.Builders;
public class CollectionTagBuilder : IEntityBuilder<CollectionTag>
{
private readonly CollectionTag _collectionTag;
public CollectionTag Build() => _collectionTag;
public CollectionTagBuilder(string title, bool promoted = false)
{
title = title.Trim();
_collectionTag = new CollectionTag()
{
Id = 0,
NormalizedTitle = title.ToNormalized(),
Title = title,
Promoted = promoted,
Summary = string.Empty,
SeriesMetadatas = new List<SeriesMetadata>()
};
}
public CollectionTagBuilder WithId(int id)
{
_collectionTag.Id = id;
return this;
}
public CollectionTagBuilder WithSummary(string summary)
{
_collectionTag.Summary = summary;
return this;
}
public CollectionTagBuilder WithIsPromoted(bool promoted)
{
_collectionTag.Promoted = promoted;
return this;
}
public CollectionTagBuilder WithSeriesMetadata(SeriesMetadata seriesMetadata)
{
_collectionTag.SeriesMetadatas ??= new List<SeriesMetadata>();
_collectionTag.SeriesMetadatas.Add(seriesMetadata);
return this;
}
public CollectionTagBuilder WithCoverImage(string cover)
{
_collectionTag.CoverImage = cover;
return this;
}
}

30
API/Helpers/Builders/DeviceBuilder.cs Normal file
View file

@ -0,0 +1,30 @@
using API.Entities;
using API.Entities.Enums.Device;
namespace API.Helpers.Builders;
public class DeviceBuilder : IEntityBuilder<Device>
{
private readonly Device _device;
public Device Build() => _device;
public DeviceBuilder(string name)
{
_device = new Device()
{
Name = name,
Platform = DevicePlatform.Custom
};
}
public DeviceBuilder WithPlatform(DevicePlatform platform)
{
_device.Platform = platform;
return this;
}
public DeviceBuilder WithEmail(string email)
{
_device.EmailAddress = email;
return this;
}
}

19
API/Helpers/Builders/FolderPathBuilder.cs Normal file
View file

@ -0,0 +1,19 @@
using System.IO;
using API.Entities;
namespace API.Helpers.Builders;
public class FolderPathBuilder : IEntityBuilder<FolderPath>
{
private readonly FolderPath _folderPath;
public FolderPath Build() => _folderPath;
public FolderPathBuilder(string directory)
{
_folderPath = new FolderPath()
{
Path = directory,
Id = 0
};
}
}

30
API/Helpers/Builders/GenreBuilder.cs Normal file
View file

@ -0,0 +1,30 @@
using System.Collections.Generic;
using API.Entities;
using API.Entities.Metadata;
using API.Extensions;
namespace API.Helpers.Builders;
public class GenreBuilder : IEntityBuilder<Genre>
{
private readonly Genre _genre;
public Genre Build() => _genre;
public GenreBuilder(string name)
{
_genre = new Genre()
{
Title = name.Trim().SentenceCase(),
NormalizedTitle = name.ToNormalized(),
Chapters = new List<Chapter>(),
SeriesMetadatas = new List<SeriesMetadata>()
};
}
public GenreBuilder WithSeriesMetadata(SeriesMetadata seriesMetadata)
{
_genre.SeriesMetadatas ??= new List<SeriesMetadata>();
_genre.SeriesMetadatas.Add(seriesMetadata);
return this;
}
}

46
API/Helpers/Builders/LibraryBuilder.cs Normal file
View file

@ -0,0 +1,46 @@
using System.Collections.Generic;
using System.Linq;
using API.Entities;
using API.Entities.Enums;
using SQLitePCL;
namespace API.Helpers.Builders;
public class LibraryBuilder : IEntityBuilder<Library>
{
private readonly Library _library;
public Library Build() => _library;
public LibraryBuilder(string name, LibraryType type = LibraryType.Manga)
{
_library = new Library()
{
Name = name,
Type = type,
Series = new List<Series>(),
Folders = new List<FolderPath>(),
AppUsers = new List<AppUser>()
};
}
public LibraryBuilder WithFolderPath(FolderPath folderPath)
{
_library.Folders ??= new List<FolderPath>();
if (_library.Folders.All(f => f != folderPath)) _library.Folders.Add(folderPath);
return this;
}
public LibraryBuilder WithSeries(Series series)
{
_library.Series ??= new List<Series>();
_library.Series.Add(series);
return this;
}
public LibraryBuilder WithAppUser(AppUser appUser)
{
_library.AppUsers ??= new List<AppUser>();
_library.AppUsers.Add(appUser);
return this;
}
}

61
API/Helpers/Builders/MangaFileBuilder.cs Normal file
View file

@ -0,0 +1,61 @@
using System;
using System.IO;
using API.Entities;
using API.Entities.Enums;
namespace API.Helpers.Builders;
public class MangaFileBuilder : IEntityBuilder<MangaFile>
{
private readonly MangaFile _mangaFile;
public MangaFile Build() => _mangaFile;
public MangaFileBuilder(string filePath, MangaFormat format, int pages = 0)
{
_mangaFile = new MangaFile()
{
FilePath = filePath,
Format = format,
Pages = pages,
LastModified = File.GetLastWriteTime(filePath),
LastModifiedUtc = File.GetLastWriteTimeUtc(filePath),
};
}
public MangaFileBuilder WithFormat(MangaFormat format)
{
_mangaFile.Format = format;
return this;
}
public MangaFileBuilder WithPages(int pages)
{
_mangaFile.Pages = Math.Max(pages, 0);
return this;
}
public MangaFileBuilder WithExtension(string extension)
{
_mangaFile.Extension = extension.ToLowerInvariant();
return this;
}
public MangaFileBuilder WithBytes(long bytes)
{
_mangaFile.Bytes = Math.Max(0, bytes);
return this;
}
public MangaFileBuilder WithLastModified(DateTime dateTime)
{
_mangaFile.LastModified = dateTime;
_mangaFile.LastModifiedUtc = dateTime.ToUniversalTime();
return this;
}
public MangaFileBuilder WithId(int id)
{
_mangaFile.Id = Math.Max(id, 0);
return this;
}
}

11
API/Helpers/Builders/PersonBuilder.cs
View file

@ -23,6 +23,17 @@ public class PersonBuilder : IEntityBuilder<Person>
};
}
/// <summary>
/// Only call for Unit Tests
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public PersonBuilder WithId(int id)
{
_person.Id = id;
return this;
}
public PersonBuilder WithSeriesMetadata(SeriesMetadata metadata)
{
_person.SeriesMetadatas ??= new List<SeriesMetadata>();

57
API/Helpers/Builders/ReadingListBuilder.cs Normal file
View file

@ -0,0 +1,57 @@
using System.Collections.Generic;
using API.Entities;
using API.Entities.Enums;
using API.Extensions;
namespace API.Helpers.Builders;
public class ReadingListBuilder : IEntityBuilder<ReadingList>
{
private readonly ReadingList _readingList;
public ReadingList Build() => _readingList;
public ReadingListBuilder(string title)
{
title = title.Trim();
_readingList = new ReadingList()
{
Title = title,
NormalizedTitle = title.ToNormalized(),
Summary = string.Empty,
Promoted = false,
Items = new List<ReadingListItem>(),
AgeRating = AgeRating.Unknown
};
}
public ReadingListBuilder WithSummary(string summary)
{
_readingList.Summary = summary ?? string.Empty;
return this;
}
public ReadingListBuilder WithItem(ReadingListItem item)
{
_readingList.Items ??= new List<ReadingListItem>();
_readingList.Items.Add(item);
return this;
}
public ReadingListBuilder WithRating(AgeRating rating)
{
_readingList.AgeRating = rating;
return this;
}
public ReadingListBuilder WithPromoted(bool promoted)
{
_readingList.Promoted = promoted;
return this;
}
public ReadingListBuilder WithCoverImage(string coverImage)
{
_readingList.CoverImage = coverImage;
return this;
}
}

21
API/Helpers/Builders/ReadingListItemBuilder.cs Normal file
View file

@ -0,0 +1,21 @@
using API.Entities;
namespace API.Helpers.Builders;
public class ReadingListItemBuilder : IEntityBuilder<ReadingListItem>
{
private readonly ReadingListItem _item;
public ReadingListItem Build() => _item;
public ReadingListItemBuilder(int index, int seriesId, int volumeId, int chapterId)
{
_item = new ReadingListItem()
{
Order = index,
ChapterId = chapterId,
SeriesId = seriesId,
VolumeId = volumeId
};
}
}

23
API/Helpers/Builders/SeriesBuilder.cs
View file

@ -26,13 +26,22 @@ public class SeriesBuilder : IEntityBuilder<Series>
SortName = name,
NormalizedName = name.ToNormalized(),
NormalizedLocalizedName = name.ToNormalized(),
Metadata = new SeriesMetadata(),
Metadata = new SeriesMetadataBuilder().Build(),
Volumes = new List<Volume>()
};
}
/// <summary>
/// Sets the localized name. If null or empty, defaults back to the
/// </summary>
/// <param name="localizedName"></param>
/// <returns></returns>
public SeriesBuilder WithLocalizedName(string localizedName)
{
if (string.IsNullOrEmpty(localizedName))
{
localizedName = _series.Name;
}
_series.LocalizedName = localizedName;
_series.NormalizedLocalizedName = localizedName.ToNormalized();
return this;
@ -68,4 +77,16 @@ public class SeriesBuilder : IEntityBuilder<Series>
_series.Pages = pages;
return this;
}
public SeriesBuilder WithCoverImage(string cover)
{
_series.CoverImage = cover;
return this;
}
public SeriesBuilder WithLibraryId(int id)
{
_series.LibraryId = id;
return this;
}
}

14
API/Helpers/Builders/SeriesMetadataBuilder.cs
View file

@ -23,14 +23,26 @@ public class SeriesMetadataBuilder : IEntityBuilder<SeriesMetadata>
public SeriesMetadataBuilder WithCollectionTag(CollectionTag tag)
{
_seriesMetadata.CollectionTags ??= new List<API.Entities.CollectionTag>();
_seriesMetadata.CollectionTags ??= new List<CollectionTag>();
_seriesMetadata.CollectionTags.Add(tag);
return this;
}
public SeriesMetadataBuilder WithCollectionTags(IList<CollectionTag> tags)
{
if (tags == null) return this;
_seriesMetadata.CollectionTags ??= new List<CollectionTag>();
_seriesMetadata.CollectionTags = tags;
return this;
}
public SeriesMetadataBuilder WithPublicationStatus(PublicationStatus status)
{
_seriesMetadata.PublicationStatus = status;
return this;
}
public SeriesMetadataBuilder WithAgeRating(AgeRating rating)
{
_seriesMetadata.AgeRating = rating;
return this;
}
}

30
API/Helpers/Builders/TagBuilder.cs Normal file
View file

@ -0,0 +1,30 @@
using System.Collections.Generic;
using API.Entities;
using API.Entities.Metadata;
using API.Extensions;
namespace API.Helpers.Builders;
public class TagBuilder : IEntityBuilder<Tag>
{
private readonly Tag _tag;
public Tag Build() => _tag;
public TagBuilder(string name)
{
_tag = new Tag()
{
Title = name.Trim().SentenceCase(),
NormalizedTitle = name.ToNormalized(),
Chapters = new List<Chapter>(),
SeriesMetadatas = new List<SeriesMetadata>()
};
}
public TagBuilder WithSeriesMetadata(SeriesMetadata seriesMetadata)
{
_tag.SeriesMetadatas ??= new List<SeriesMetadata>();
_tag.SeriesMetadatas.Add(seriesMetadata);
return this;
}
}

19
API/Helpers/Builders/VolumeBuilder.cs
View file

@ -12,7 +12,12 @@ public class VolumeBuilder : IEntityBuilder<Volume>
public VolumeBuilder(string volumeNumber)
{
_volume = DbFactory.Volume(volumeNumber);
_volume = new Volume()
{
Name = volumeNumber,
Number = (int) Services.Tasks.Scanner.Parser.Parser.MinNumberFromRange(volumeNumber),
Chapters = new List<Chapter>()
};
}
public VolumeBuilder WithName(string name)
@ -40,4 +45,16 @@ public class VolumeBuilder : IEntityBuilder<Volume>
_volume.Pages = _volume.Chapters.Sum(c => c.Pages);
return this;
}
public VolumeBuilder WithSeriesId(int seriesId)
{
_volume.SeriesId = seriesId;
return this;
}
public VolumeBuilder WithCoverImage(string cover)
{
_volume.CoverImage = cover;
return this;
}
}

5
API/Helpers/GenreHelper.cs
View file

@ -5,6 +5,7 @@ using API.Data;
using API.DTOs.Metadata;
using API.Entities;
using API.Extensions;
using API.Helpers.Builders;
namespace API.Helpers;
@ -26,7 +27,7 @@ public static class GenreHelper
var genre = allGenres.FirstOrDefault(p => p.NormalizedTitle != null && p.NormalizedTitle.Equals(normalizedName));
if (genre == null)
{
genre = DbFactory.Genre(name);
genre = new GenreBuilder(name).Build();
allGenres.Add(genre);
}
@ -99,7 +100,7 @@ public static class GenreHelper
else
{
// Add new tag
handleAdd(DbFactory.Genre(tagTitle));
handleAdd(new GenreBuilder(tagTitle).Build());
isModified = true;
}
}

2
API/Helpers/ParserInfoHelpers.cs
View file

@ -2,8 +2,8 @@
using API.Entities;
using API.Entities.Enums;
using API.Extensions;
using API.Parser;
using API.Services.Tasks.Scanner;
using API.Services.Tasks.Scanner.Parser;
namespace API.Helpers;

30
API/Helpers/PersonHelper.cs
View file

@ -1,8 +1,6 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using API.Data;
using API.DTOs;
using API.Entities;
using API.Entities.Enums;
@ -25,6 +23,7 @@ public static class PersonHelper
/// <param name="action"></param>
public static void UpdatePeople(ICollection<Person> allPeople, IEnumerable<string> names, PersonRole role, Action<Person> action)
{
// TODO: Validate if we need this, not used
var allPeopleTypeRole = allPeople.Where(p => p.Role == role).ToList();
foreach (var name in names)
@ -34,7 +33,7 @@ public static class PersonHelper
p.NormalizedName != null && p.NormalizedName.Equals(normalizedName));
if (person == null)
{
person = DbFactory.Person(name, role);
person = new PersonBuilder(name, role).Build();
allPeople.Add(person);
}
@ -102,7 +101,7 @@ public static class PersonHelper
public static void AddPersonIfNotExists(ICollection<Person> metadataPeople, Person person)
{
if (string.IsNullOrEmpty(person.Name)) return;
var existingPerson = metadataPeople.SingleOrDefault(p =>
var existingPerson = metadataPeople.FirstOrDefault(p =>
p.NormalizedName == person.Name.ToNormalized() && p.Role == person.Role);
if (existingPerson == null)
{
@ -110,21 +109,16 @@ public static class PersonHelper
}
}
/// <summary>
/// Adds the person to the list if it's not already in there
/// </summary>
/// <param name="metadataPeople"></param>
/// <param name="person"></param>
public static void AddPersonIfNotExists(BlockingCollection<Person> metadataPeople, Person person)
{
var existingPerson = metadataPeople.SingleOrDefault(p =>
p.NormalizedName == person.Name?.ToNormalized() && p.Role == person.Role);
if (existingPerson == null)
{
metadataPeople.Add(person);
}
}
/// <summary>
/// For a given role and people dtos, update a series
/// </summary>
/// <param name="role"></param>
/// <param name="tags"></param>
/// <param name="series"></param>
/// <param name="allTags"></param>
/// <param name="handleAdd">This will call with an existing or new tag, but the method does not update the series Metadata</param>
/// <param name="onModified"></param>
public static void UpdatePeopleList(PersonRole role, ICollection<PersonDto>? tags, Series series, IReadOnlyCollection<Person> allTags,
Action<Person> handleAdd, Action onModified)
{

5
API/Helpers/TagHelper.cs
View file

@ -6,6 +6,7 @@ using API.Data;
using API.DTOs.Metadata;
using API.Entities;
using API.Extensions;
using API.Helpers.Builders;
namespace API.Helpers;
@ -31,7 +32,7 @@ public static class TagHelper
if (genre == null)
{
added = true;
genre = DbFactory.Tag(name);
genre = new TagBuilder(name).Build();
allTags.Add(genre);
}
@ -129,7 +130,7 @@ public static class TagHelper
else
{
// Add new tag
handleAdd(DbFactory.Tag(tagTitle));
handleAdd(new TagBuilder(tagTitle).Build());
isModified = true;
}
}

2
API/Services/BookService.cs
View file

@ -11,7 +11,7 @@ using API.Data.Metadata;
using API.DTOs.Reader;
using API.Entities;
using API.Entities.Enums;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
using Docnet.Core;
using Docnet.Core.Converters;
using Docnet.Core.Models;

3
API/Services/CollectionTagService.cs
View file

@ -7,6 +7,7 @@ using API.Data.Repositories;
using API.DTOs.CollectionTags;
using API.Entities;
using API.Entities.Metadata;
using API.Helpers.Builders;
using API.SignalR;
using Kavita.Common;
@ -163,7 +164,7 @@ public class CollectionTagService : ICollectionTagService
/// <returns></returns>
public CollectionTag CreateTag(string title)
{
var tag = DbFactory.CollectionTag(0, title, string.Empty, false);
var tag = new CollectionTagBuilder(title).Build();
_unitOfWork.CollectionTagRepository.Add(tag);
return tag;
}

8
API/Services/DeviceService.cs
View file

@ -8,6 +8,7 @@ using API.DTOs.Email;
using API.Entities;
using API.Entities.Enums;
using API.Entities.Enums.Device;
using API.Helpers.Builders;
using Kavita.Common;
using Microsoft.Extensions.Logging;
@ -42,9 +43,10 @@ public class DeviceService : IDeviceService
var existingDevice = userWithDevices.Devices.SingleOrDefault(d => d.Name!.Equals(dto.Name));
if (existingDevice != null) throw new KavitaException("A device with this name already exists");
existingDevice = DbFactory.Device(dto.Name);
existingDevice.Platform = dto.Platform;
existingDevice.EmailAddress = dto.EmailAddress;
existingDevice = new DeviceBuilder(dto.Name)
.WithPlatform(dto.Platform)
.WithEmail(dto.EmailAddress)
.Build();
userWithDevices.Devices.Add(existingDevice);

1
API/Services/ReadingItemService.cs
View file

@ -1,7 +1,6 @@
using System;
using API.Data.Metadata;
using API.Entities.Enums;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
namespace API.Services;

11
API/Services/ReadingListService.cs
View file

@ -12,6 +12,7 @@ using API.DTOs.ReadingLists.CBL;
using API.Entities;
using API.Entities.Enums;
using API.Helpers;
using API.Helpers.Builders;
using API.SignalR;
using Kavita.Common;
using Microsoft.Extensions.Logging;
@ -118,7 +119,7 @@ public class ReadingListService : IReadingListService
throw new KavitaException("A list of this name already exists");
}
var readingList = DbFactory.ReadingList(title, string.Empty, false);
var readingList = new ReadingListBuilder(title).Build();
userWithReadingList.ReadingLists.Add(readingList);
if (!_unitOfWork.HasChanges()) throw new KavitaException("There was a problem creating list");
@ -410,7 +411,7 @@ public class ReadingListService : IReadingListService
var index = readingList.Items.Count == 0 ? 0 : lastOrder + 1;
foreach (var chapter in chaptersForSeries.Where(chapter => !existingChapterExists.Contains(chapter.Id)))
{
readingList.Items.Add(DbFactory.ReadingListItem(index, seriesId, chapter.VolumeId, chapter.Id));
readingList.Items.Add(new ReadingListItemBuilder(index, seriesId, chapter.VolumeId, chapter.Id).Build());
index += 1;
}
@ -509,7 +510,7 @@ public class ReadingListService : IReadingListService
var allReadingLists = (user.ReadingLists).ToDictionary(s => s.NormalizedTitle);
if (!allReadingLists.TryGetValue(readingListNameNormalized, out var readingList))
{
readingList = DbFactory.ReadingList(cblReading.Name, cblReading.Summary, false);
readingList = new ReadingListBuilder(cblReading.Name).WithSummary(cblReading.Summary).Build();
user.ReadingLists.Add(readingList);
}
else
@ -645,8 +646,8 @@ public class ReadingListService : IReadingListService
item.SeriesId == seriesId && item.ChapterId == chapterId);
if (readingListItem != null) return;
readingListItem = DbFactory.ReadingListItem(readingList.Items.Count, seriesId,
volumeId, chapterId);
readingListItem = new ReadingListItemBuilder(readingList.Items.Count, seriesId,
volumeId, chapterId).Build();
readingList.Items.Add(readingListItem);
}

17
API/Services/SeriesService.cs
View file

@ -13,6 +13,7 @@ using API.Entities;
using API.Entities.Enums;
using API.Entities.Metadata;
using API.Helpers;
using API.Helpers.Builders;
using API.SignalR;
using Microsoft.Extensions.Logging;
@ -69,8 +70,14 @@ public class SeriesService : ISeriesService
var allPeople = (await _unitOfWork.PersonRepository.GetAllPeople()).ToList();
var allTags = (await _unitOfWork.TagRepository.GetAllTagsAsync()).ToList();
series.Metadata ??= DbFactory.SeriesMetadata((updateSeriesMetadataDto.CollectionTags ?? new List<CollectionTagDto>())
.Select(dto => DbFactory.CollectionTag(dto.Id, dto.Title, dto.Summary, dto.Promoted)).ToList());
series.Metadata ??= new SeriesMetadataBuilder()
.WithCollectionTags(updateSeriesMetadataDto.CollectionTags.Select(dto =>
new CollectionTagBuilder(dto.Title)
.WithId(dto.Id)
.WithSummary(dto.Summary)
.WithIsPromoted(dto.Promoted)
.Build()).ToList())
.Build();
if (series.Metadata.AgeRating != updateSeriesMetadataDto.SeriesMetadata.AgeRating)
{
@ -244,7 +251,11 @@ public class SeriesService : ISeriesService
else
{
// Add new tag
handleAdd(DbFactory.CollectionTag(tag.Id, tag.Title, tag.Summary, tag.Promoted));
handleAdd(new CollectionTagBuilder(tag.Title)
.WithId(tag.Id)
.WithSummary(tag.Summary)
.WithIsPromoted(tag.Promoted)
.Build());
}
}
}

2
API/Services/Tasks/Scanner/ParseScannedFiles.cs
View file

@ -6,7 +6,7 @@ using System.Linq;
using System.Threading.Tasks;
using API.Entities.Enums;
using API.Extensions;
using API.Parser;
using API.Services.Tasks.Scanner.Parser;
using API.SignalR;
using Kavita.Common.Helpers;
using Microsoft.Extensions.Logging;

4
API/Services/Tasks/Scanner/Parser/DefaultParser.cs
View file

@ -1,7 +1,6 @@
using System.IO;
using System.Linq;
using API.Entities.Enums;
using API.Parser;
namespace API.Services.Tasks.Scanner.Parser;
@ -34,8 +33,9 @@ public class DefaultParser : IDefaultParser
public ParserInfo? Parse(string filePath, string rootPath, LibraryType type = LibraryType.Manga)
{
var fileName = _directoryService.FileSystem.Path.GetFileNameWithoutExtension(filePath);
// TODO: Potential Bug: This will return null, but on Image libraries, if all images, we would want to include this.
// TODO: Potential Bug: This will return null, but on Image libraries, if all images, we would want to include this. (we can probably remove this and have users use kavitaignore)
if (Parser.IsCoverImage(_directoryService.FileSystem.Path.GetFileName(filePath))) return null;
ParserInfo ret;
if (Parser.IsEpub(filePath))

3
API/Services/Tasks/Scanner/Parser/ParserInfo.cs
View file

@ -1,8 +1,7 @@
using API.Data.Metadata;
using API.Entities.Enums;
using API.Services.Tasks.Scanner.Parser;
namespace API.Parser;
namespace API.Services.Tasks.Scanner.Parser;
/// <summary>
/// This represents all parsed information from a single file

407
API/Services/Tasks/Scanner/ProcessSeries.cs
View file

@ -11,8 +11,9 @@ using API.Entities;
using API.Entities.Enums;
using API.Extensions;
using API.Helpers;
using API.Parser;
using API.Helpers.Builders;
using API.Services.Tasks.Metadata;
using API.Services.Tasks.Scanner.Parser;
using API.SignalR;
using Hangfire;
using Kavita.Common;
@ -29,6 +30,13 @@ public interface IProcessSeries
Task Prime();
Task ProcessSeriesAsync(IList<ParserInfo> parsedInfos, Library library, bool forceUpdate = false);
void EnqueuePostSeriesProcessTasks(int libraryId, int seriesId, bool forceUpdate = false);
// These exists only for Unit testing
void UpdateSeriesMetadata(Series series, Library library);
void UpdateVolumes(Series series, IList<ParserInfo> parsedInfos, bool forceUpdate = false);
void UpdateChapters(Series series, Volume volume, IList<ParserInfo> parsedInfos, bool forceUpdate = false);
void AddOrUpdateFileForChapter(Chapter chapter, ParserInfo info, bool forceUpdate = false);
void UpdateChapterFromComicInfo(Chapter chapter, ComicInfo? info);
}
/// <summary>
@ -51,9 +59,9 @@ public class ProcessSeries : IProcessSeries
private IList<Person> _people;
private Dictionary<string, Tag> _tags;
private Dictionary<string, CollectionTag> _collectionTags;
private readonly object _peopleLock;
private readonly object _genreLock;
private readonly object _tagLock;
private readonly object _peopleLock = new object();
private readonly object _genreLock = new object();
private readonly object _tagLock = new object();
public ProcessSeries(IUnitOfWork unitOfWork, ILogger<ProcessSeries> logger, IEventHub eventHub,
IDirectoryService directoryService, ICacheHelper cacheHelper, IReadingItemService readingItemService,
@ -71,6 +79,7 @@ public class ProcessSeries : IProcessSeries
_wordCountAnalyzerService = wordCountAnalyzerService;
_collectionTagService = collectionTagService;
_genres = new Dictionary<string, Genre>();
_people = new List<Person>();
_tags = new Dictionary<string, Tag>();
@ -122,7 +131,9 @@ public class ProcessSeries : IProcessSeries
if (series == null)
{
seriesAdded = true;
series = DbFactory.Series(firstInfo.Series, firstInfo.LocalizedSeries);
series = new SeriesBuilder(firstInfo.Series)
.WithLocalizedName(firstInfo.LocalizedSeries)
.Build();
_unitOfWork.SeriesRepository.Add(series);
}
@ -217,7 +228,7 @@ public class ProcessSeries : IProcessSeries
//if (!library.ManageReadingLists) return;
_logger.LogInformation("Generating Reading Lists for {SeriesName}", series.Name);
series.Metadata ??= DbFactory.SeriesMetadata(new List<CollectionTag>());
series.Metadata ??= new SeriesMetadataBuilder().Build();
foreach (var chapter in series.Volumes.SelectMany(v => v.Chapters))
{
if (!string.IsNullOrEmpty(chapter.StoryArc))
@ -261,9 +272,9 @@ public class ProcessSeries : IProcessSeries
BackgroundJob.Enqueue(() => _wordCountAnalyzerService.ScanSeries(libraryId, seriesId, forceUpdate));
}
private void UpdateSeriesMetadata(Series series, Library library)
public void UpdateSeriesMetadata(Series series, Library library)
{
series.Metadata ??= DbFactory.SeriesMetadata(new List<CollectionTag>());
series.Metadata ??= new SeriesMetadataBuilder().Build();
var isBook = library.Type == LibraryType.Book;
var firstChapter = SeriesService.GetFirstChapterForMetadata(series, isBook);
@ -333,159 +344,164 @@ public class ProcessSeries : IProcessSeries
}
}
// Handle People
foreach (var chapter in chapters)
lock (_genreLock)
{
if (!series.Metadata.WriterLocked)
var genres = chapters.SelectMany(c => c.Genres).ToList();
GenreHelper.KeepOnlySameGenreBetweenLists(series.Metadata.Genres.ToList(), genres, genre =>
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Writer))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.CoverArtistLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.CoverArtist))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.PublisherLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Publisher))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.CharacterLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Character))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.ColoristLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Colorist))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.EditorLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Editor))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.InkerLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Inker))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.LettererLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Letterer))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.PencillerLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Penciller))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.TranslatorLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Translator))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.TagsLocked)
{
foreach (var tag in chapter.Tags)
{
TagHelper.AddTagIfNotExists(series.Metadata.Tags, tag);
}
}
if (!series.Metadata.GenresLocked)
{
foreach (var genre in chapter.Genres)
{
GenreHelper.AddGenreIfNotExists(series.Metadata.Genres, genre);
}
}
if (series.Metadata.GenresLocked) return; // NOTE: Doesn't it make sense to do the locked skip outside this loop?
series.Metadata.Genres.Remove(genre);
});
}
var genres = chapters.SelectMany(c => c.Genres).ToList();
GenreHelper.KeepOnlySameGenreBetweenLists(series.Metadata.Genres.ToList(), genres, genre =>
// Handle People
lock (_peopleLock)
{
if (series.Metadata.GenresLocked) return; // NOTE: Doesn't it make sense to do the locked skip outside this loop?
series.Metadata.Genres.Remove(genre);
});
// NOTE: The issue here is that people is just from chapter, but series metadata might already have some people on it
// I might be able to filter out people that are in locked fields?
var people = chapters.SelectMany(c => c.People).ToList();
PersonHelper.KeepOnlySamePeopleBetweenLists(series.Metadata.People.ToList(),
people, person =>
foreach (var chapter in chapters)
{
switch (person.Role)
if (!series.Metadata.WriterLocked)
{
case PersonRole.Writer:
if (!series.Metadata.WriterLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Penciller:
if (!series.Metadata.PencillerLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Inker:
if (!series.Metadata.InkerLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Colorist:
if (!series.Metadata.ColoristLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Letterer:
if (!series.Metadata.LettererLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.CoverArtist:
if (!series.Metadata.CoverArtistLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Editor:
if (!series.Metadata.EditorLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Publisher:
if (!series.Metadata.PublisherLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Character:
if (!series.Metadata.CharacterLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Translator:
if (!series.Metadata.TranslatorLocked) series.Metadata.People.Remove(person);
break;
default:
series.Metadata.People.Remove(person);
break;
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Writer))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
});
if (!series.Metadata.CoverArtistLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.CoverArtist))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.PublisherLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Publisher))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.CharacterLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Character))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.ColoristLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Colorist))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.EditorLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Editor))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.InkerLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Inker))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.LettererLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Letterer))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.PencillerLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Penciller))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.TranslatorLocked)
{
foreach (var person in chapter.People.Where(p => p.Role == PersonRole.Translator))
{
PersonHelper.AddPersonIfNotExists(series.Metadata.People, person);
}
}
if (!series.Metadata.TagsLocked)
{
foreach (var tag in chapter.Tags)
{
TagHelper.AddTagIfNotExists(series.Metadata.Tags, tag);
}
}
if (!series.Metadata.GenresLocked)
{
foreach (var genre in chapter.Genres)
{
GenreHelper.AddGenreIfNotExists(series.Metadata.Genres, genre);
}
}
}
// NOTE: The issue here is that people is just from chapter, but series metadata might already have some people on it
// I might be able to filter out people that are in locked fields?
var people = chapters.SelectMany(c => c.People).ToList();
PersonHelper.KeepOnlySamePeopleBetweenLists(series.Metadata.People.ToList(),
people, person =>
{
switch (person.Role)
{
case PersonRole.Writer:
if (!series.Metadata.WriterLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Penciller:
if (!series.Metadata.PencillerLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Inker:
if (!series.Metadata.InkerLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Colorist:
if (!series.Metadata.ColoristLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Letterer:
if (!series.Metadata.LettererLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.CoverArtist:
if (!series.Metadata.CoverArtistLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Editor:
if (!series.Metadata.EditorLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Publisher:
if (!series.Metadata.PublisherLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Character:
if (!series.Metadata.CharacterLocked) series.Metadata.People.Remove(person);
break;
case PersonRole.Translator:
if (!series.Metadata.TranslatorLocked) series.Metadata.People.Remove(person);
break;
default:
series.Metadata.People.Remove(person);
break;
}
});
}
}
private void UpdateVolumes(Series series, IList<ParserInfo> parsedInfos, bool forceUpdate = false)
public void UpdateVolumes(Series series, IList<ParserInfo> parsedInfos, bool forceUpdate = false)
{
var startingVolumeCount = series.Volumes.Count;
// Add new volumes and update chapters per volume
@ -493,7 +509,7 @@ public class ProcessSeries : IProcessSeries
_logger.LogDebug("[ScannerService] Updating {DistinctVolumes} volumes on {SeriesName}", distinctVolumes.Count, series.Name);
foreach (var volumeNumber in distinctVolumes)
{
_logger.LogDebug("[ScannerService] Looking up volume for {VolumeNumber}", volumeNumber);
_logger.LogTrace("[ScannerService] Looking up volume for {VolumeNumber}", volumeNumber);
Volume? volume;
try
{
@ -511,8 +527,9 @@ public class ProcessSeries : IProcessSeries
}
if (volume == null)
{
volume = DbFactory.Volume(volumeNumber);
volume.SeriesId = series.Id;
volume = new VolumeBuilder(volumeNumber)
.WithSeriesId(series.Id)
.Build();
series.Volumes.Add(volume);
}
@ -568,7 +585,7 @@ public class ProcessSeries : IProcessSeries
series.Name, startingVolumeCount, series.Volumes.Count);
}
private void UpdateChapters(Series series, Volume volume, IList<ParserInfo> parsedInfos, bool forceUpdate = false)
public void UpdateChapters(Series series, Volume volume, IList<ParserInfo> parsedInfos, bool forceUpdate = false)
{
// Add new chapters
foreach (var info in parsedInfos)
@ -590,7 +607,7 @@ public class ProcessSeries : IProcessSeries
{
_logger.LogDebug(
"[ScannerService] Adding new chapter, {Series} - Vol {Volume} Ch {Chapter}", info.Series, info.Volumes, info.Chapters);
chapter = DbFactory.Chapter(info);
chapter = ChapterBuilder.FromParserInfo(info).Build();
volume.Chapters.Add(chapter);
series.UpdateLastChapterAdded();
}
@ -628,7 +645,7 @@ public class ProcessSeries : IProcessSeries
}
}
private void AddOrUpdateFileForChapter(Chapter chapter, ParserInfo info, bool forceUpdate = false)
public void AddOrUpdateFileForChapter(Chapter chapter, ParserInfo info, bool forceUpdate = false)
{
chapter.Files ??= new List<MangaFile>();
var existingFile = chapter.Files.SingleOrDefault(f => f.FilePath == info.FullFilePath);
@ -644,15 +661,16 @@ public class ProcessSeries : IProcessSeries
}
else
{
var file = DbFactory.MangaFile(info.FullFilePath, info.Format, _readingItemService.GetNumberOfPages(info.FullFilePath, info.Format));
if (file == null) return;
file.Extension = fileInfo.Extension.ToLowerInvariant();
file.Bytes = fileInfo.Length;
var file = new MangaFileBuilder(info.FullFilePath, info.Format, _readingItemService.GetNumberOfPages(info.FullFilePath, info.Format))
.WithExtension(fileInfo.Extension)
.WithBytes(fileInfo.Length)
.Build();
chapter.Files.Add(file);
}
}
private void UpdateChapterFromComicInfo(Chapter chapter, ComicInfo? info)
public void UpdateChapterFromComicInfo(Chapter chapter, ComicInfo? info)
{
var firstFile = chapter.Files.MinBy(x => x.Chapter);
if (firstFile == null ||
@ -665,7 +683,7 @@ public class ProcessSeries : IProcessSeries
}
if (comicInfo == null) return;
_logger.LogDebug("[ScannerService] Read ComicInfo for {File}", firstFile.FilePath);
_logger.LogTrace("[ScannerService] Read ComicInfo for {File}", firstFile.FilePath);
chapter.AgeRating = ComicInfo.ConvertAgeRatingToEnum(comicInfo.AgeRating);
@ -749,70 +767,59 @@ public class ProcessSeries : IProcessSeries
var people = GetTagValues(comicInfo.Colorist);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Colorist);
UpdatePeople(people, PersonRole.Colorist,
AddPerson);
UpdatePeople(people, PersonRole.Colorist, AddPerson);
people = GetTagValues(comicInfo.Characters);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Character);
UpdatePeople(people, PersonRole.Character,
AddPerson);
UpdatePeople(people, PersonRole.Character, AddPerson);
people = GetTagValues(comicInfo.Translator);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Translator);
UpdatePeople(people, PersonRole.Translator,
AddPerson);
UpdatePeople(people, PersonRole.Translator, AddPerson);
people = GetTagValues(comicInfo.Writer);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Writer);
UpdatePeople(people, PersonRole.Writer,
AddPerson);
UpdatePeople(people, PersonRole.Writer, AddPerson);
people = GetTagValues(comicInfo.Editor);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Editor);
UpdatePeople(people, PersonRole.Editor,
AddPerson);
UpdatePeople(people, PersonRole.Editor, AddPerson);
people = GetTagValues(comicInfo.Inker);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Inker);
UpdatePeople(people, PersonRole.Inker,
AddPerson);
UpdatePeople(people, PersonRole.Inker, AddPerson);
people = GetTagValues(comicInfo.Letterer);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Letterer);
UpdatePeople(people, PersonRole.Letterer,
AddPerson);
UpdatePeople(people, PersonRole.Letterer, AddPerson);
people = GetTagValues(comicInfo.Penciller);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Penciller);
UpdatePeople(people, PersonRole.Penciller,
AddPerson);
UpdatePeople(people, PersonRole.Penciller, AddPerson);
people = GetTagValues(comicInfo.CoverArtist);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.CoverArtist);
UpdatePeople(people, PersonRole.CoverArtist,
AddPerson);
UpdatePeople(people, PersonRole.CoverArtist, AddPerson);
people = GetTagValues(comicInfo.Publisher);
PersonHelper.RemovePeople(chapter.People, people, PersonRole.Publisher);
UpdatePeople(people, PersonRole.Publisher,
AddPerson);
UpdatePeople(people, PersonRole.Publisher, AddPerson);
var genres = GetTagValues(comicInfo.Genre);
GenreHelper.KeepOnlySameGenreBetweenLists(chapter.Genres,
genres.Select(DbFactory.Genre).ToList());
genres.Select(g => new GenreBuilder(g).Build()).ToList());
UpdateGenre(genres, AddGenre);
var tags = GetTagValues(comicInfo.Tags);
TagHelper.KeepOnlySameTagBetweenLists(chapter.Tags, tags.Select(DbFactory.Tag).ToList());
TagHelper.KeepOnlySameTagBetweenLists(chapter.Tags, tags.Select(t => new TagBuilder(t).Build()).ToList());
UpdateTag(tags, AddTag);
}
private static IList<string> GetTagValues(string comicInfoTagSeparatedByComma)
{
// TODO: Move this to an extension and test it
if (!string.IsNullOrEmpty(comicInfoTagSeparatedByComma))
{
return comicInfoTagSeparatedByComma.Split(",").Select(s => s.Trim()).DistinctBy(Parser.Parser.Normalize).ToList();
@ -831,23 +838,23 @@ public class ProcessSeries : IProcessSeries
/// <param name="action"></param>
private void UpdatePeople(IEnumerable<string> names, PersonRole role, Action<Person> action)
{
var allPeopleTypeRole = _people.Where(p => p.Role == role).ToList();
foreach (var name in names)
lock (_peopleLock)
{
var normalizedName = name.ToNormalized();
var person = allPeopleTypeRole.FirstOrDefault(p =>
p.NormalizedName != null && p.NormalizedName.Equals(normalizedName));
if (person == null)
var allPeopleTypeRole = _people.Where(p => p.Role == role).ToList();
foreach (var name in names)
{
person = DbFactory.Person(name, role);
lock (_peopleLock)
var normalizedName = name.ToNormalized();
var person = allPeopleTypeRole.FirstOrDefault(p =>
p.NormalizedName != null && p.NormalizedName.Equals(normalizedName));
if (person == null)
{
person = new PersonBuilder(name, role).Build();
_people.Add(person);
}
}
action(person);
action(person);
}
}
}
@ -867,7 +874,7 @@ public class ProcessSeries : IProcessSeries
var newTag = genre == null;
if (newTag)
{
genre = DbFactory.Genre(name);
genre = new GenreBuilder(name).Build();
lock (_genreLock)
{
_genres.Add(normalizedName, genre);
@ -896,7 +903,7 @@ public class ProcessSeries : IProcessSeries
var added = tag == null;
if (tag == null)
{
tag = DbFactory.Tag(name);
tag = new TagBuilder(name).Build();
lock (_tagLock)
{
_tags.Add(normalizedName, tag);

2
API/Services/Tasks/ScannerService.cs
View file

@ -11,9 +11,9 @@ using API.Entities;
using API.Entities.Enums;
using API.Extensions;
using API.Helpers;
using API.Parser;
using API.Services.Tasks.Metadata;
using API.Services.Tasks.Scanner;
using API.Services.Tasks.Scanner.Parser;
using API.SignalR;
using Hangfire;
using Microsoft.Extensions.Logging;

47
API/Services/TokenService.cs
View file

@ -28,6 +28,7 @@ public class TokenService : ITokenService
{
private readonly UserManager<AppUser> _userManager;
private readonly SymmetricSecurityKey _key;
private const string RefreshTokenName = "RefreshToken";
public TokenService(IConfiguration config, UserManager<AppUser> userManager)
{
@ -65,28 +66,40 @@ public class TokenService : ITokenService
public async Task<string> CreateRefreshToken(AppUser user)
{
await _userManager.RemoveAuthenticationTokenAsync(user, TokenOptions.DefaultProvider, "RefreshToken");
var refreshToken = await _userManager.GenerateUserTokenAsync(user, TokenOptions.DefaultProvider, "RefreshToken");
await _userManager.SetAuthenticationTokenAsync(user, TokenOptions.DefaultProvider, "RefreshToken", refreshToken);
await _userManager.RemoveAuthenticationTokenAsync(user, TokenOptions.DefaultProvider, RefreshTokenName);
var refreshToken = await _userManager.GenerateUserTokenAsync(user, TokenOptions.DefaultProvider, RefreshTokenName);
await _userManager.SetAuthenticationTokenAsync(user, TokenOptions.DefaultProvider, RefreshTokenName, refreshToken);
return refreshToken;
}
public async Task<TokenRequestDto?> ValidateRefreshToken(TokenRequestDto request)
{
var tokenHandler = new JwtSecurityTokenHandler();
var tokenContent = tokenHandler.ReadJwtToken(request.Token);
var username = tokenContent.Claims.FirstOrDefault(q => q.Type == JwtRegisteredClaimNames.NameId)?.Value;
if (string.IsNullOrEmpty(username)) return null;
var user = await _userManager.FindByNameAsync(username);
if (user == null) return null; // This forces a logout
await _userManager.VerifyUserTokenAsync(user, TokenOptions.DefaultProvider, "RefreshToken", request.RefreshToken);
await _userManager.UpdateSecurityStampAsync(user);
return new TokenRequestDto()
try
{
Token = await CreateToken(user),
RefreshToken = await CreateRefreshToken(user)
};
var tokenHandler = new JwtSecurityTokenHandler();
var tokenContent = tokenHandler.ReadJwtToken(request.Token);
var username = tokenContent.Claims.FirstOrDefault(q => q.Type == JwtRegisteredClaimNames.NameId)?.Value;
if (string.IsNullOrEmpty(username)) return null;
var user = await _userManager.FindByIdAsync(username);
if (user == null) return null; // This forces a logout
var validated = await _userManager.VerifyUserTokenAsync(user, TokenOptions.DefaultProvider, RefreshTokenName, request.RefreshToken);
if (!validated) return null;
await _userManager.UpdateSecurityStampAsync(user);
return new TokenRequestDto()
{
Token = await CreateToken(user),
RefreshToken = await CreateRefreshToken(user)
};
} catch (SecurityTokenExpiredException)
{
// Handle expired token
return null;
}
catch (Exception)
{
// Handle other exceptions
return null;
}
}
}

7
API/Startup.cs
View file

@ -185,13 +185,6 @@ public class Startup
{
options.AddPolicy("Authentication", httpContext =>
new AuthenticationRateLimiterPolicy().GetPartition(httpContext));
// RateLimitPartition.GetFixedWindowLimiter(httpContext.Connection.RemoteIpAddress?.ToString(),
// partition => new FixedWindowRateLimiterOptions
// {
// AutoReplenishment = true,
// PermitLimit = 1,
// Window = TimeSpan.FromMinutes(1),
// }));
});
services.AddHangfire(configuration => configuration