Synchronizer error factory implementation (#645)

* Added sync error factories for outlook and gmail.

* Implement ObjectCannotBeDeletedHandler for OutlookSynchronizer.

* Remove debug code.

* Implement del key to delete on mail list.

* Revert debug code.

Wino.Core/Services/GmailSynchronizerErrorHandlingFactory.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Errors;
+
+namespace Wino.Core.Services;
+public class GmailSynchronizerErrorHandlingFactory : SynchronizerErrorHandlingFactory, IGmailSynchronizerErrorHandlerFactory
+{
+    public bool CanHandle(SynchronizerErrorContext error) => CanHandle(error);
+
+    public Task HandleAsync(SynchronizerErrorContext error) => HandleErrorAsync(error);
+}

Wino.Core/Services/OutlookSynchronizerErrorHandlingFactory.cs

@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Errors;
+using Wino.Core.Synchronizers.Errors.Outlook;
+
+namespace Wino.Core.Services;
+
+public class OutlookSynchronizerErrorHandlingFactory : SynchronizerErrorHandlingFactory, IOutlookSynchronizerErrorHandlerFactory
+{
+    public OutlookSynchronizerErrorHandlingFactory(ObjectCannotBeDeletedHandler objectCannotBeDeleted)
+    {
+        RegisterHandler(objectCannotBeDeleted);
+    }
+
+    public bool CanHandle(SynchronizerErrorContext error) => CanHandle(error);
+
+    public Task HandleAsync(SynchronizerErrorContext error) => HandleErrorAsync(error);
+}

Wino.Core/Services/SynchronizerErrorHandlingFactory.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Serilog;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Errors;
+
+namespace Wino.Core.Services;
+
+/// <summary>
+/// Factory for handling synchronizer errors
+/// </summary>
+public class SynchronizerErrorHandlingFactory
+{
+    private readonly ILogger _logger = Log.ForContext<SynchronizerErrorHandlingFactory>();
+    private readonly List<ISynchronizerErrorHandler> _handlers = new();
+
+    /// <summary>
+    /// Registers an error handler
+    /// </summary>
+    /// <param name="handler">The handler to register</param>
+    public void RegisterHandler(ISynchronizerErrorHandler handler)
+    {
+        _handlers.Add(handler);
+    }
+
+    /// <summary>
+    /// Handles an error using the registered handlers
+    /// </summary>
+    /// <param name="error">The error to handle</param>
+    /// <returns>True if the error was handled, false otherwise</returns>
+    public async Task<bool> HandleErrorAsync(SynchronizerErrorContext error)
+    {
+        foreach (var handler in _handlers)
+        {
+            if (handler.CanHandle(error))
+            {
+                _logger.Debug("Found handler {HandlerType} for error code {ErrorCode} message {ErrorMessage}",
+                    handler.GetType().Name, error.ErrorCode, error.ErrorMessage);
+
+                return await handler.HandleAsync(error);
+            }
+        }
+
+        _logger.Debug("No handler found for error code {ErrorCode} message {ErrorMessage}",
+            error.ErrorCode, error.ErrorMessage);
+
+        return false;
+    }
+}

Wino.Core/Services/SynchronizerFactory.cs

@@ -15,6 +15,8 @@ public class SynchronizerFactory : ISynchronizerFactory
     private readonly IAccountService _accountService;
     private readonly IImapSynchronizationStrategyProvider _imapSynchronizationStrategyProvider;
     private readonly IApplicationConfiguration _applicationConfiguration;
+    private readonly IOutlookSynchronizerErrorHandlerFactory _outlookSynchronizerErrorHandlerFactory;
+    private readonly IGmailSynchronizerErrorHandlerFactory _gmailSynchronizerErrorHandlerFactory;
     private readonly IOutlookChangeProcessor _outlookChangeProcessor;
     private readonly IGmailChangeProcessor _gmailChangeProcessor;
     private readonly IImapChangeProcessor _imapChangeProcessor;
@@ -30,7 +32,9 @@ public class SynchronizerFactory : ISynchronizerFactory
                                IGmailAuthenticator gmailAuthenticator,
                                IAccountService accountService,
                                IImapSynchronizationStrategyProvider imapSynchronizationStrategyProvider,
-                               IApplicationConfiguration applicationConfiguration)
+                               IApplicationConfiguration applicationConfiguration,
+                               IOutlookSynchronizerErrorHandlerFactory outlookSynchronizerErrorHandlerFactory,
+                               IGmailSynchronizerErrorHandlerFactory gmailSynchronizerErrorHandlerFactory)
     {
         _outlookChangeProcessor = outlookChangeProcessor;
         _gmailChangeProcessor = gmailChangeProcessor;
@@ -40,6 +44,8 @@ public class SynchronizerFactory : ISynchronizerFactory
         _accountService = accountService;
         _imapSynchronizationStrategyProvider = imapSynchronizationStrategyProvider;
         _applicationConfiguration = applicationConfiguration;
+        _outlookSynchronizerErrorHandlerFactory = outlookSynchronizerErrorHandlerFactory;
+        _gmailSynchronizerErrorHandlerFactory = gmailSynchronizerErrorHandlerFactory;
     }
 
     public async Task<IWinoSynchronizerBase> GetAccountSynchronizerAsync(Guid accountId)
@@ -69,9 +75,9 @@ public class SynchronizerFactory : ISynchronizerFactory
         switch (providerType)
         {
             case Domain.Enums.MailProviderType.Outlook:
-                return new OutlookSynchronizer(mailAccount, _outlookAuthenticator, _outlookChangeProcessor);
+                return new OutlookSynchronizer(mailAccount, _outlookAuthenticator, _outlookChangeProcessor, _outlookSynchronizerErrorHandlerFactory);
             case Domain.Enums.MailProviderType.Gmail:
-                return new GmailSynchronizer(mailAccount, _gmailAuthenticator, _gmailChangeProcessor);
+                return new GmailSynchronizer(mailAccount, _gmailAuthenticator, _gmailChangeProcessor, _gmailSynchronizerErrorHandlerFactory);
             case Domain.Enums.MailProviderType.IMAP4:
                 return new ImapSynchronizer(mailAccount, _imapChangeProcessor, _imapSynchronizationStrategyProvider, _applicationConfiguration);
             default: