Write (failing) unit tests for comming development

API.Tests/Helpers/PersonHelperTests.cs

@@ -177,4 +177,48 @@ public class PersonHelperTests : AbstractDbTest
         Assert.Contains(chapterPeople, cp => cp.Role == PersonRole.Writer);
         Assert.Contains(chapterPeople, cp => cp.Role == PersonRole.Editor);
     }
+
+    [Fact]
+    public async Task UpdateChapterPeopleAsync_MatchOnAlias_NoChanges()
+    {
+        await ResetDb();
+
+        var library = new LibraryBuilder("My Library")
+            .Build();
+
+        UnitOfWork.LibraryRepository.Add(library);
+        await UnitOfWork.CommitAsync();
+
+        var person = new PersonBuilder("Joe Doe")
+            .WithAlias("Jonny Doe")
+            .Build();
+
+        var chapter = new ChapterBuilder("1")
+            .WithPerson(person, PersonRole.Editor)
+            .Build();
+
+        var series = new SeriesBuilder("Test 1")
+            .WithLibraryId(library.Id)
+            .WithVolume(new VolumeBuilder("1")
+                .WithChapter(chapter)
+                .Build())
+            .Build();
+
+        UnitOfWork.SeriesRepository.Add(series);
+        await UnitOfWork.CommitAsync();
+
+        // Add on Name
+        await PersonHelper.UpdateChapterPeopleAsync(chapter, new List<string> { "Joe Doe" }, PersonRole.Editor, UnitOfWork);
+        await UnitOfWork.CommitAsync();
+
+        var allPeople = await UnitOfWork.PersonRepository.GetAllPeople();
+        Assert.Single(allPeople);
+
+        // Add on alias
+        await PersonHelper.UpdateChapterPeopleAsync(chapter, new List<string> { "Jonny Doe" }, PersonRole.Editor, UnitOfWork);
+        await UnitOfWork.CommitAsync();
+
+        allPeople = await UnitOfWork.PersonRepository.GetAllPeople();
+        Assert.Single(allPeople);
+    }
 }

API.Tests/Services/ExternalMetadataServiceTests.cs

@@ -1678,6 +1678,86 @@ public class ExternalMetadataServiceTests : AbstractDbTest
 
     #endregion
 
+    #region People Alias
+
+    [Fact]
+    public async Task PeopleAliasing_AddAsAlias()
+    {
+        await ResetDb();
+
+        const string seriesName = "Test - People - Add as Alias";
+        var series = new SeriesBuilder(seriesName)
+            .WithLibraryId(1)
+            .WithMetadata(new SeriesMetadataBuilder()
+                .Build())
+            .Build();
+        Context.Series.Attach(series);
+        await Context.SaveChangesAsync();
+
+        var metadataSettings = await UnitOfWork.SettingsRepository.GetMetadataSettings();
+        metadataSettings.Enabled = true;
+        metadataSettings.EnablePeople = true;
+        metadataSettings.FirstLastPeopleNaming = true;
+        metadataSettings.Overrides = [MetadataSettingField.People];
+        metadataSettings.PersonRoles = [PersonRole.Writer];
+        Context.MetadataSettings.Update(metadataSettings);
+        await Context.SaveChangesAsync();
+
+        await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesDetailDto()
+        {
+            Name = seriesName,
+            Staff = [CreateStaff("John", "Doe", "Story"), CreateStaff("Doe", "John", "Story")]
+        }, 1);
+
+        var postSeries = await UnitOfWork.SeriesRepository.GetSeriesByIdAsync(1, SeriesIncludes.Metadata);
+        Assert.NotNull(postSeries);
+
+        var allWriters = postSeries.Metadata.People.Where(p => p.Role == PersonRole.Writer).ToList();
+        Assert.Single(allWriters);
+
+        var johnDoe = allWriters[0].Person;
+
+        Assert.Contains("Doe John", johnDoe.Aliases.Select(pa => pa.Alias));
+    }
+
+    [Fact]
+    public async Task PeopleAliasing_DontAddAsAlias_SameButNotSwitched()
+    {
+        await ResetDb();
+
+        const string seriesName = "Test - People - Add as Alias";
+        var series = new SeriesBuilder(seriesName)
+            .WithLibraryId(1)
+            .WithMetadata(new SeriesMetadataBuilder()
+                .Build())
+            .Build();
+        Context.Series.Attach(series);
+        await Context.SaveChangesAsync();
+
+        var metadataSettings = await UnitOfWork.SettingsRepository.GetMetadataSettings();
+        metadataSettings.Enabled = true;
+        metadataSettings.EnablePeople = true;
+        metadataSettings.FirstLastPeopleNaming = true;
+        metadataSettings.Overrides = [MetadataSettingField.People];
+        metadataSettings.PersonRoles = [PersonRole.Writer];
+        Context.MetadataSettings.Update(metadataSettings);
+        await Context.SaveChangesAsync();
+
+        await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesDetailDto()
+        {
+            Name = seriesName,
+            Staff = [CreateStaff("John", "Doe Doe", "Story"), CreateStaff("Doe", "John Doe", "Story")]
+        }, 1);
+
+        var postSeries = await UnitOfWork.SeriesRepository.GetSeriesByIdAsync(1, SeriesIncludes.Metadata);
+        Assert.NotNull(postSeries);
+
+        var allWriters = postSeries.Metadata.People.Where(p => p.Role == PersonRole.Writer).ToList();
+        Assert.Equal(2, allWriters.Count);
+    }
+
+    #endregion
+
     #region People - Characters
 
     [Fact]

API.Tests/Services/PersonServiceTests.cs

@@ -0,0 +1,138 @@
+using System.Linq;
+using System.Threading.Tasks;
+using API.Entities.Enums;
+using API.Entities.Person;
+using API.Extensions;
+using API.Helpers.Builders;
+using API.Services;
+using Xunit;
+
+namespace API.Tests.Services;
+
+public class PersonServiceTests: AbstractDbTest
+{
+
+    [Fact]
+    public async Task PersonMerge_KeepNonEmptyMetadata()
+    {
+        var ps = new PersonService(UnitOfWork);
+
+        var person1 = new Person
+        {
+            Name = "Casey Delores",
+            NormalizedName = "Casey Delores".ToNormalized(),
+            HardcoverId = "ANonEmptyId",
+            MalId = 12,
+        };
+
+        var person2 = new Person
+        {
+            Name= "Delores Casey",
+            NormalizedName = "Delores Casey".ToNormalized(),
+            Description = "Hi, I'm Delores Casey!",
+            AniListId = 27,
+        };
+
+        UnitOfWork.PersonRepository.Attach(person1);
+        UnitOfWork.PersonRepository.Attach(person2);
+        await UnitOfWork.CommitAsync();
+
+        await ps.MergePeopleAsync(person1, person2);
+
+        var allPeople = await UnitOfWork.PersonRepository.GetAllPeople();
+        Assert.Single(allPeople);
+
+        var person = allPeople[0];
+        Assert.Equal("Casey Delores", person.Name);
+        Assert.NotEmpty(person.Description);
+        Assert.Equal(27, person.AniListId);
+        Assert.NotNull(person.HardcoverId);
+        Assert.NotEmpty(person.HardcoverId);
+        Assert.Contains(person.Aliases, pa => pa.Alias == "Delores Casey");
+    }
+
+    [Fact]
+    public async Task PersonMerge_MergedPersonDestruction()
+    {
+        var ps = new PersonService(UnitOfWork);
+
+        var person1 = new Person
+        {
+            Name = "Casey Delores",
+            NormalizedName = "Casey Delores".ToNormalized(),
+        };
+
+        var person2 = new Person
+        {
+            Name = "Delores Casey",
+            NormalizedName = "Delores Casey".ToNormalized(),
+        };
+
+        UnitOfWork.PersonRepository.Attach(person1);
+        UnitOfWork.PersonRepository.Attach(person2);
+        await UnitOfWork.CommitAsync();
+
+        await ps.MergePeopleAsync(person1, person2);
+        var allPeople = await UnitOfWork.PersonRepository.GetAllPeople();
+        Assert.Single(allPeople);
+    }
+
+    [Fact]
+    public async Task PersonMerge_RetentionChapters()
+    {
+        var ps = new PersonService(UnitOfWork);
+
+        var library = new LibraryBuilder("My Library").Build();
+        UnitOfWork.LibraryRepository.Add(library);
+        await UnitOfWork.CommitAsync();
+
+        var person = new PersonBuilder("Jillian Cowan").Build();
+
+        var person2 = new PersonBuilder("Cowan Jillian").Build();
+
+        var chapter = new ChapterBuilder("1")
+            .WithPerson(person, PersonRole.Editor)
+            .Build();
+
+        var chapter2 = new ChapterBuilder("2")
+            .WithPerson(person2, PersonRole.Editor)
+            .Build();
+
+        var series = new SeriesBuilder("Test 1")
+            .WithLibraryId(library.Id)
+            .WithVolume(new VolumeBuilder("1")
+                .WithChapter(chapter)
+                .Build())
+            .Build();
+
+        var series2 = new SeriesBuilder("Test 2")
+            .WithLibraryId(library.Id)
+            .WithVolume(new VolumeBuilder("2")
+                .WithChapter(chapter2)
+                .Build())
+            .Build();
+
+        UnitOfWork.SeriesRepository.Add(series);
+        UnitOfWork.SeriesRepository.Add(series2);
+        await UnitOfWork.CommitAsync();
+
+        await ps.MergePeopleAsync(person, person2);
+
+        var allPeople = await UnitOfWork.PersonRepository.GetAllPeople();
+        Assert.Single(allPeople);
+        var mergedPerson = allPeople[0];
+
+        Assert.Equal("Jillian Cowan", mergedPerson.Name);
+
+        // UserId here might bug out?
+        var chapters = await UnitOfWork.PersonRepository.GetChaptersForPersonByRole(1, 1, PersonRole.Editor);
+        Assert.Equal(2, chapters.Count());
+    }
+
+    protected override async Task ResetDb()
+    {
+        Context.Person.RemoveRange(Context.Person.ToList());
+
+        await Context.SaveChangesAsync();
+    }
+}

API/Data/DataContext.cs

@@ -49,6 +49,7 @@ public sealed class DataContext : IdentityDbContext<AppUser, AppRole, int,
     public DbSet<ReadingList> ReadingList { get; set; } = null!;
     public DbSet<ReadingListItem> ReadingListItem { get; set; } = null!;
     public DbSet<Person> Person { get; set; } = null!;
+    public DbSet<PersonAlias> PersonAlias { get; set; } = null!;
     public DbSet<Genre> Genre { get; set; } = null!;
     public DbSet<Tag> Tag { get; set; } = null!;
     public DbSet<SiteTheme> SiteTheme { get; set; } = null!;

API/Entities/Person/Person.cs

@@ -8,8 +8,7 @@ public class Person : IHasCoverImage
     public int Id { get; set; }
     public required string Name { get; set; }
     public required string NormalizedName { get; set; }
-
+    public ICollection<PersonAlias> Aliases { get; set; } = [];
-    //public ICollection<PersonAlias> Aliases { get; set; } = default!;
 
     public string? CoverImage { get; set; }
     public bool CoverImageLocked { get; set; }

API/Entities/Person/PersonAlias.cs

@@ -0,0 +1,10 @@
+namespace API.Entities.Person;
+
+public class PersonAlias
+{
+    public int Id { get; set; }
+
+    public string Alias { get; set; }
+
+    public string NormalizedAlias { get; set; }
+}

API/Helpers/Builders/PersonBuilder.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using API.Entities;
 using API.Entities.Enums;
 using API.Entities.Metadata;
@@ -34,6 +35,23 @@ public class PersonBuilder : IEntityBuilder<Person>
         return this;
     }
 
+    public PersonBuilder WithAlias(string alias)
+    {
+        if (_person.Aliases.Any(a => a.NormalizedAlias.Equals(alias)))
+        {
+            return this;
+        }
+
+        _person.Aliases.Add(new PersonAlias()
+        {
+            Alias = alias,
+            NormalizedAlias = alias.ToNormalized(),
+        });
+        return this;
+    }
+
+
+
     public PersonBuilder WithSeriesMetadata(SeriesMetadataPeople seriesMetadataPeople)
     {
         _person.SeriesMetadataPeople.Add(seriesMetadataPeople);

API/Services/PersonService.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using API.Data;
+using API.Entities.Person;
+
+namespace API.Services;
+
+public interface IPersonService
+{
+    /// <summary>
+    /// Adds src as an alias to dst, this is a destructive operation
+    /// </summary>
+    /// <param name="dst">Remaining person</param>
+    /// <param name="src">Merged person</param>
+    /// <returns></returns>
+    Task MergePeopleAsync(Person dst, Person src);
+}
+
+public class PersonService(IUnitOfWork unitOfWork): IPersonService
+{
+
+    public async Task MergePeopleAsync(Person dst, Person src)
+    {
+        throw new System.NotImplementedException();
+    }
+}