Finished the unit tests

API.Tests/Extensions/SeriesFilterTests.cs

@@ -932,11 +932,11 @@ private async Task<AppUser> SetupHasRating()
 
         var seriesService = new SeriesService(_unitOfWork, Substitute.For<IEventHub>(),
             Substitute.For<ITaskScheduler>(), Substitute.For<ILogger<SeriesService>>(),
-            Substitute.For<IScrobblingService>(), Substitute.For<ILocalizationService>()
-            , Substitute.For<IImageService>());
+            Substitute.For<IScrobblingService>(), Substitute.For<ILocalizationService>());
 
         // Select 0 Rating
         var zeroRating = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(2);
+        Assert.NotNull(zeroRating);
 
         Assert.True(await seriesService.UpdateRating(user, new UpdateSeriesRatingDto()
         {

API.Tests/Services/ExternalMetadataServiceTests.cs

@@ -2150,7 +2150,7 @@ await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesD
 
     // Non-Sequel existing relationship with new link, both exist
     [Fact]
-    public async Task Relationships_NonSequel_ExistingLink_DifferentType()
+    public async Task Relationships_NonSequel_ExistingLink_DifferentType_BothExist()
     {
         await ResetDb();
 
@@ -2189,6 +2189,7 @@ public async Task Relationships_NonSequel_ExistingLink_DifferentType()
         _context.MetadataSettings.Update(metadataSettings);
         await _context.SaveChangesAsync();
 
+
         await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesDetailDto()
         {
             Name = seriesName,
@@ -2202,22 +2203,78 @@ await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesD
                     NativeTitle = series2.Name,
                     RomajiTitle = series2.Name,
                 },
-                AniListId = 10,
                 PlusMediaFormat = PlusMediaFormat.Manga
             }]
-        }, 1);
+        }, 2);
 
         // Repull Series and validate what is overwritten
-        var sourceSeries = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(2, SeriesIncludes.Metadata | SeriesIncludes.Related);
+       var sourceSeries = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(2, SeriesIncludes.Metadata | SeriesIncludes.Related);
         Assert.NotNull(sourceSeries);
-        Assert.Contains(sourceSeries.Relations, r => r.RelationKind == RelationKind.Annual);
-        Assert.Contains(sourceSeries.Relations, r => r.RelationKind == RelationKind.SideStory);
+        Assert.Equal(seriesName, sourceSeries.Name);
+
+        Assert.Contains(sourceSeries.Relations, r => r.RelationKind == RelationKind.Annual && r.TargetSeriesId == existingRelationshipSeries.Id);
+        Assert.Contains(sourceSeries.Relations, r => r.RelationKind == RelationKind.SideStory && r.TargetSeriesId == series2.Id);
     }
 
 
 
     // Sequel/Prequel
+    [Fact]
+    public async Task Relationships_Sequel_CreatesPrequel()
+    {
+        await ResetDb();
+
+        const string seriesName = "Test - Relationships Source";
+        var series = new SeriesBuilder(seriesName)
+            .WithLibraryId(1)
+            .WithFormat(MangaFormat.Archive)
+            .WithMetadata(new SeriesMetadataBuilder()
+                .Build())
+            .Build();
+        _context.Series.Attach(series);
+
+        var series2 = new SeriesBuilder("Test - Relationships Target")
+            .WithLibraryId(1)
+            .WithFormat(MangaFormat.Archive)
+            .WithMetadata(new SeriesMetadataBuilder()
+                .Build())
+            .Build();
+        _context.Series.Attach(series2);
+        await _context.SaveChangesAsync();
+
+        var metadataSettings = await _unitOfWork.SettingsRepository.GetMetadataSettings();
+        metadataSettings.Enabled = true;
+        metadataSettings.EnableRelationships = true;
+        _context.MetadataSettings.Update(metadataSettings);
+        await _context.SaveChangesAsync();
+
+        await _externalMetadataService.WriteExternalMetadataToSeries(new ExternalSeriesDetailDto()
+        {
+            Name = seriesName,
+            Relations = [new SeriesRelationship()
+            {
+                Relation = RelationKind.Sequel,
+                SeriesName = new ALMediaTitle()
+                {
+                    PreferredTitle = series2.Name,
+                    EnglishTitle = null,
+                    NativeTitle = series2.Name,
+                    RomajiTitle = series2.Name,
+                },
+                PlusMediaFormat = PlusMediaFormat.Manga
+            }]
+        }, 1);
 
+        // Repull Series and validate what is overwritten
+        var sourceSeries = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(1, SeriesIncludes.Metadata | SeriesIncludes.Related);
+        Assert.NotNull(sourceSeries);
+        Assert.Single(sourceSeries.Relations);
+        Assert.Equal(series2.Name, sourceSeries.Relations.First().TargetSeries.Name);
+
+        var sequel = await _unitOfWork.SeriesRepository.GetSeriesByIdAsync(2, SeriesIncludes.Metadata | SeriesIncludes.Related);
+        Assert.NotNull(sequel);
+        Assert.Equal(seriesName, sequel.Relations.First().TargetSeries.Name);
+    }
 
 
     #endregion

API.Tests/Services/SeriesServiceTests.cs

@@ -56,7 +56,7 @@ public SeriesServiceTests()
 
         _seriesService = new SeriesService(_unitOfWork, Substitute.For<IEventHub>(),
             Substitute.For<ITaskScheduler>(), Substitute.For<ILogger<SeriesService>>(),
-            Substitute.For<IScrobblingService>(), locService, Substitute.For<IImageService>());
+            Substitute.For<IScrobblingService>(), locService);
     }
     #region Setup
 

API/Data/Repositories/SeriesRepository.cs

@@ -75,6 +75,7 @@ public interface ISeriesRepository
 {
     void Add(Series series);
     void Attach(Series series);
+    void Attach(SeriesRelation relation);
     void Update(Series series);
     void Remove(Series series);
     void Remove(IEnumerable<Series> series);
@@ -198,6 +199,11 @@ public void Attach(Series series)
         _context.Series.Attach(series);
     }
 
+    public void Attach(SeriesRelation relation)
+    {
+        _context.SeriesRelation.Attach(relation);
+    }
+
     public void Attach(ExternalSeriesMetadata metadata)
     {
         _context.ExternalSeriesMetadata.Attach(metadata);

API/Helpers/Builders/SeriesBuilder.cs

@@ -124,7 +124,6 @@ public SeriesBuilder WithRelationship(int targetSeriesId, RelationKind kind)
         _series.Relations ??= [];
         _series.Relations.Add(new SeriesRelation()
         {
-            SeriesId = _series.Id,
             RelationKind = kind,
             TargetSeriesId = targetSeriesId
         });

API/Services/Plus/ExternalMetadataService.cs

@@ -522,8 +522,6 @@ public async Task<bool> WriteExternalMetadataToSeries(ExternalSeriesDetailDto ex
         madeModification = await UpdateCharacters(series, settings, externalMetadata.Characters) || madeModification;
 
         madeModification = await UpdateRelationships(series, settings, externalMetadata.Relations, defaultAdmin) || madeModification;
-
-        // MUST be last as this will commit
         madeModification = await UpdateCoverImage(series, settings, externalMetadata) || madeModification;
 
         return madeModification;
@@ -582,43 +580,13 @@ private async Task<bool> UpdateRelationships(Series series, MetadataSettingsDto
             // Skip if no related series found or series is the parent
             if (relatedSeries == null || relatedSeries.Id == series.Id || relation.Relation == RelationKind.Parent) continue;
 
-            if (relatedSeries != null && relatedSeries.Id != series.Id && relation.Relation != RelationKind.Parent)
-            {
-                relatedSeriesDict[relatedSeries.Id] = relatedSeries;
-            }
+            // Check if the relationship already exists
+            var relationshipExists = series.Relations.Any(r =>
+                r.TargetSeriesId == relatedSeries.Id && r.RelationKind == relation.Relation);
+
+            if (relationshipExists) continue;
 
-            // // Check if the relationship already exists
-            // var relationshipExists = series.Relations.Any(r =>
-            //     r.TargetSeriesId == relatedSeries.Id && r.RelationKind == relation.Relation);
-            //
-            // if (relationshipExists) continue;
-            //
-            // series.Relations.Add(new SeriesRelation
-            // {
-            //     RelationKind = relation.Relation,
-            //     TargetSeries = relatedSeries,
-            //     TargetSeriesId = relatedSeries.Id,
-            // });
-            //
-            // _unitOfWork.SeriesRepository.Attach(series);
-            //
-            // // Handle sequel/prequel: add reverse relationship
-            // if (relation.Relation is RelationKind.Prequel or RelationKind.Sequel)
-            // {
-            //     var reverseExists = relatedSeries.Relations.Any(r =>
-            //         r.TargetSeriesId == series.Id && r.RelationKind == GetReverseRelation(relation.Relation));
-            //
-            //     if (reverseExists) continue;
-            //
-            //     relatedSeries.Relations.Add(new SeriesRelation
-            //     {
-            //         RelationKind = GetReverseRelation(relation.Relation),
-            //         TargetSeries = series,
-            //         TargetSeriesId = series.Id,
-            //         Series = relatedSeries,
-            //         SeriesId = relatedSeries.Id
-            //     });
-            // }
+            relatedSeriesDict[relatedSeries.Id] = relatedSeries;
         }
 
         // Process relationships
@@ -631,17 +599,12 @@ private async Task<bool> UpdateRelationships(Series series, MetadataSettingsDto
 
             if (relatedSeries == null) continue;
 
-            // Check if the relationship already exists
-            var relationshipExists = series.Relations.Any(r =>
-                r.TargetSeriesId == relatedSeries.Id && r.RelationKind == relation.Relation);
-
-            if (relationshipExists) continue;
-
             // Add new relationship
             var newRelation = new SeriesRelation
             {
                 RelationKind = relation.Relation,
-                TargetSeriesId = relatedSeries.Id
+                TargetSeriesId = relatedSeries.Id,
+                SeriesId = series.Id,
             };
             series.Relations.Add(newRelation);
 
@@ -656,11 +619,15 @@ private async Task<bool> UpdateRelationships(Series series, MetadataSettingsDto
                     var reverseRelation = new SeriesRelation
                     {
                         RelationKind = GetReverseRelation(relation.Relation),
-                        TargetSeriesId = series.Id
+                        TargetSeriesId = series.Id,
+                        SeriesId = relatedSeries.Id,
                     };
                     relatedSeries.Relations.Add(reverseRelation);
+                    _unitOfWork.SeriesRepository.Attach(reverseRelation);
                 }
             }
+
+            _unitOfWork.SeriesRepository.Update(series);
         }
 
         if (_unitOfWork.HasChanges())

API/Services/SeriesService.cs

@@ -1,28 +1,22 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using API.Comparators;
-using API.Constants;
-using API.Controllers;
 using API.Data;
 using API.Data.Repositories;
 using API.DTOs;
-using API.DTOs.CollectionTags;
 using API.DTOs.SeriesDetail;
 using API.Entities;
 using API.Entities.Enums;
-using API.Entities.Interfaces;
 using API.Entities.Metadata;
 using API.Extensions;
 using API.Helpers;
 using API.Helpers.Builders;
 using API.Services.Plus;
 using API.Services.Tasks.Scanner.Parser;
 using API.SignalR;
-using EasyCaching.Core;
 using Hangfire;
 using Kavita.Common;
 using Microsoft.Extensions.Logging;
@@ -56,7 +50,6 @@ public class SeriesService : ISeriesService
     private readonly ILogger<SeriesService> _logger;
     private readonly IScrobblingService _scrobblingService;
     private readonly ILocalizationService _localizationService;
-    private readonly IImageService _imageService;
 
     private readonly NextExpectedChapterDto _emptyExpectedChapter = new NextExpectedChapterDto
     {
@@ -66,15 +59,14 @@ public class SeriesService : ISeriesService
     };
 
     public SeriesService(IUnitOfWork unitOfWork, IEventHub eventHub, ITaskScheduler taskScheduler,
-        ILogger<SeriesService> logger, IScrobblingService scrobblingService, ILocalizationService localizationService, IImageService imageService)
+        ILogger<SeriesService> logger, IScrobblingService scrobblingService, ILocalizationService localizationService)
     {
         _unitOfWork = unitOfWork;
         _eventHub = eventHub;
         _taskScheduler = taskScheduler;
         _logger = logger;
         _scrobblingService = scrobblingService;
         _localizationService = localizationService;
-        _imageService = imageService;
     }
 
     /// <summary>