Implement Importing subscriptions

subtrack.MAUI/MauiProgram.cs

@@ -54,6 +54,7 @@ public static IServiceCollection AddSubtrackServices(this IServiceCollection ser
             services
             .AddDbContext<SubtrackDbContext>(opt => opt.UseSqlite(dbConnectionString))
             .AddScoped<ISubscriptionService, SubscriptionService>()
+            .AddScoped<ISubscriptionsImporter, SubscriptionsImporter>()
             .AddScoped<IDateProvider, DateProvider>()
             .AddScoped<ISubscriptionsCalculator, SubscriptionsCalculator>()
             .AddScoped<ISettingsService, SettingsService>()

subtrack.MAUI/Pages/Settings.razor

@@ -1,15 +1,19 @@
 @page "/settings"
 
+@inject ISubscriptionsImporter subscriptionImporter
 @inject ISubscriptionService subscriptionService
 
 @using CsvHelper
 
 <div class="d-flex justify-content-start mb-3">
     <div class="p-2">Import</div>
     <div class="p-2">
-        <InputFile />
+        <InputFile OnChange="ImportSubscriptions" />
     </div>
 </div>
+
+<p>@_importResult</p>
+
 <div class="d-flex justify-content-start mb-3">
     <div class="p-2">
         Last Export:
@@ -20,19 +24,36 @@
 </div>
 
 @code {
+    private string _importResult = string.Empty;
+
     private async Task ExportSubscriptions()
     {
         using var csv = new StringWriter();
         using var csvWriter = new CsvWriter(csv, CultureInfo.InvariantCulture);
+        csvWriter.Context.RegisterClassMap<SubscriptionCsvMapping>();    
 
         var subscriptions = await subscriptionService.GetAllAsync();
-        csvWriter.WriteRecords(subscriptions);
+        await csvWriter.WriteRecordsAsync(subscriptions);
 
         await Share.Default.RequestAsync(new ShareTextRequest
         {
             Title = "subtrack subs",
-            Subject = $"subtrack-subs_{DateTime.Now:dd-MM-yyyy-HH.mm}.csv",
+            Subject = $"subtrack-subs_{DateTime.Now:dd-MM-yyyy}.csv",
             Text = csv.ToString()
         });
     }
+
+    private async Task ImportSubscriptions(InputFileChangeEventArgs e)
+    {
+        try
+        {
+            var maxFileSizeInBytes = (long)Math.Round(1.Megabytes().Bytes);
+            var importedSubscriptions = await subscriptionImporter.ImportFromCsvAsync(e.File.OpenReadStream(maxAllowedSize: maxFileSizeInBytes));
+            _importResult = $"imported {importedSubscriptions.Count} subscriptions";
+        }
+        catch (Exception ex)
+        {
+            _importResult = ex.Message;
+        }
+    }
 }

subtrack.MAUI/Services/Abstractions/ISubscriptionService.cs

@@ -7,6 +7,7 @@ public interface ISubscriptionService
     {
         Task<IEnumerable<Subscription>> GetAllAsync(GetSubscriptionsFilter? filter = null);
         Task<Subscription> CreateSubscriptionAsync(Subscription subscriptionToCreate);
+        Task<IReadOnlyCollection<Subscription>> CreateSubscriptionsAsync(IEnumerable<Subscription> subscriptionsToCreate);
         Task<Subscription?> GetByIdIfExists(int id);
         Task Delete(int id);
         Task Update(Subscription subscriptionToUpdate);

subtrack.MAUI/Services/Abstractions/ISubscriptionsImporter.cs

@@ -0,0 +1,8 @@
+using subtrack.DAL.Entities;
+
+namespace subtrack.MAUI.Services.Abstractions;
+
+public interface ISubscriptionsImporter
+{
+    Task<IReadOnlyCollection<Subscription>> ImportFromCsvAsync(Stream content);
+}

subtrack.MAUI/Services/SubscriptionService.cs

@@ -66,15 +66,26 @@ public async Task Delete(int id)
 
         public async Task<Subscription> CreateSubscriptionAsync(Subscription subscriptionToCreate)
         {
-            subscriptionToCreate.LastPayment = subscriptionToCreate.LastPayment.Date;
-            subscriptionToCreate.FirstPaymentDay = subscriptionToCreate.LastPayment.Day;
-            AutoPay(subscriptionToCreate);
+            SetupNewSubscription(subscriptionToCreate);
             await _context.Subscriptions.AddAsync(subscriptionToCreate);
             await _context.SaveChangesAsync();
-
             return subscriptionToCreate;
         }
 
+        public async Task<IReadOnlyCollection<Subscription>> CreateSubscriptionsAsync(IEnumerable<Subscription> subscriptionsToCreate)
+        {
+            var newSubscriptions = subscriptionsToCreate.Select(s =>
+            {
+                SetupNewSubscription(s);
+                return s;
+            }).ToArray();
+
+            await _context.Subscriptions.AddRangeAsync(newSubscriptions);
+            await _context.SaveChangesAsync();
+
+            return newSubscriptions;
+        }
+
         public async Task<Subscription> MarkNextPaymentAsPaidAsync(int subscriptionId)
         {
             var sub = await GetByIdAsync(subscriptionId);
@@ -93,6 +104,12 @@ public async Task<Subscription> AutoPayAsync(int subscriptionId)
             return subscription;
         }
 
+        private void SetupNewSubscription(Subscription subscriptionToCreate)
+        {
+            subscriptionToCreate.LastPayment = subscriptionToCreate.LastPayment.Date;
+            subscriptionToCreate.FirstPaymentDay = subscriptionToCreate.LastPayment.Day;
+            AutoPay(subscriptionToCreate);
+        }
         private void AutoPay(Subscription subscription)
         {
             if (!subscription.IsAutoPaid)

subtrack.MAUI/Services/SubscriptionsImporter.cs

@@ -0,0 +1,31 @@
+using CsvHelper;
+using subtrack.DAL.Entities;
+using subtrack.MAUI.Services.Abstractions;
+using subtrack.MAUI.Utilities;
+using System.Globalization;
+
+namespace subtrack.MAUI.Services;
+internal class SubscriptionsImporter : ISubscriptionsImporter
+{
+    private readonly ISubscriptionService _subscriptionService;
+
+    public SubscriptionsImporter(ISubscriptionService subscriptionService)
+    {
+        _subscriptionService = subscriptionService;
+    }
+
+    public async Task<IReadOnlyCollection<Subscription>> ImportFromCsvAsync(Stream content)
+    {
+        using var csv = new StreamReader(content);
+        using var csvReader = new CsvReader(csv, CultureInfo.InvariantCulture);
+        csvReader.Context.RegisterClassMap<SubscriptionCsvMapping>();
+
+        var subscriptionsToImport = new List<Subscription>();
+        await foreach (var subscription in csvReader.GetRecordsAsync<Subscription>())
+        {
+            subscriptionsToImport.Add(subscription);
+        }
+
+        return await _subscriptionService.CreateSubscriptionsAsync(subscriptionsToImport);
+    }
+}

subtrack.MAUI/Utilities/CsvMappings.cs

@@ -0,0 +1,14 @@
+using CsvHelper.Configuration;
+using subtrack.DAL.Entities;
+using System.Globalization;
+
+namespace subtrack.MAUI.Utilities;
+
+public class SubscriptionCsvMapping : ClassMap<Subscription>
+{
+    public SubscriptionCsvMapping()
+    {
+        AutoMap(CultureInfo.InvariantCulture);
+        Map(m => m.Id).Ignore();
+    }
+}

subtrack.Tests/Integration/SubscriptionImporterTests.cs

@@ -0,0 +1,55 @@
+using CsvHelper.TypeConversion;
+using System.Text;
+
+namespace subtrack.Tests.Integration;
+
+public class SubscriptionImporterTests : IntegrationTestBase
+{
+    private ISubscriptionsImporter _sut;
+
+    public SubscriptionImporterTests()
+    {
+        _sut = _serviceProvider.GetRequiredService<ISubscriptionsImporter>();
+    }
+
+    [Fact]
+    public async Task ImportCsv_InvalidCsv_ShouldThrow()
+    {
+        var csvText = @"Name,Description,IsAutoPaid,Cost,FirstPaymentDay,LastPayment,BillingOccurrence,BillingInterval,PrimaryColor,Icon,SecondaryColor
+Subscription1,Description1,True,29.99,1,2023-12-01,Monthly,1,,,,,,
+";
+        var csv = new MemoryStream(Encoding.UTF8.GetBytes(csvText));
+
+        await Assert.ThrowsAsync<TypeConverterException>(async () => await _sut.ImportFromCsvAsync(csv));
+    }
+
+    [Fact]
+    public async Task ImportCsv_EmptyValuesForOptionalProperties_ShouldReturnImportedItems()
+    {
+        var csvText = @"Name,Description,IsAutoPaid,Cost,FirstPaymentDay,LastPayment,BillingOccurrence,BillingInterval,PrimaryColor,Icon,SecondaryColor
+Subscription1,Description1,True,29.99,1,2023-12-01,Month,1,,,,,,
+Subscription2,,True,29.99,1,2023-12-01,Month,1,,,,,,
+";
+        var csv = new MemoryStream(Encoding.UTF8.GetBytes(csvText));
+
+        var importedSubs = await _sut.ImportFromCsvAsync(csv);
+
+        Assert.Equal(2, importedSubs.Count);
+    }
+
+    [Fact]
+    public async Task ImportCsv_WithSameDetailsAsExisting_ShouldReturnImportedSubs()
+    {
+        var existingSubscription = CreateSubscription(DateTime.Today, description: null);
+        var csvText = $@"Name,Description,IsAutoPaid,Cost,FirstPaymentDay,LastPayment,BillingOccurrence,BillingInterval,PrimaryColor,Icon,SecondaryColor
+{existingSubscription.Name},,{existingSubscription.IsAutoPaid},{existingSubscription.Cost},{existingSubscription.FirstPaymentDay},{existingSubscription.LastPayment},{existingSubscription.BillingOccurrence},{existingSubscription.BillingInterval},,,,,,
+Subscription1,,True,29.99,1,2023-12-01,Month,1,,,,,,
+Subscription2,,False,29.99,1,2022-12-01,Week,1,,,,,,
+";
+        var csv = new MemoryStream(Encoding.UTF8.GetBytes(csvText));
+
+        var importedSubs = await _sut.ImportFromCsvAsync(csv);
+
+        Assert.Equal(3, importedSubs.Count);
+    }
+}