file scoped namespaces (#565)

Wino.Core/Services/SynchronizerFactory.cs

@@ -6,121 +6,120 @@ using Wino.Core.Domain.Interfaces;
 using Wino.Core.Integration.Processors;
 using Wino.Core.Synchronizers.Mail;
 
-namespace Wino.Core.Services
+namespace Wino.Core.Services;
+
+public class SynchronizerFactory : ISynchronizerFactory
 {
-    public class SynchronizerFactory : ISynchronizerFactory
+    private bool isInitialized = false;
+
+    private readonly IAccountService _accountService;
+    private readonly IImapSynchronizationStrategyProvider _imapSynchronizationStrategyProvider;
+    private readonly IApplicationConfiguration _applicationConfiguration;
+    private readonly IOutlookChangeProcessor _outlookChangeProcessor;
+    private readonly IGmailChangeProcessor _gmailChangeProcessor;
+    private readonly IImapChangeProcessor _imapChangeProcessor;
+    private readonly IOutlookAuthenticator _outlookAuthenticator;
+    private readonly IGmailAuthenticator _gmailAuthenticator;
+
+    private readonly List<IWinoSynchronizerBase> synchronizerCache = new();
+
+    public SynchronizerFactory(IOutlookChangeProcessor outlookChangeProcessor,
+                               IGmailChangeProcessor gmailChangeProcessor,
+                               IImapChangeProcessor imapChangeProcessor,
+                               IOutlookAuthenticator outlookAuthenticator,
+                               IGmailAuthenticator gmailAuthenticator,
+                               IAccountService accountService,
+                               IImapSynchronizationStrategyProvider imapSynchronizationStrategyProvider,
+                               IApplicationConfiguration applicationConfiguration)
     {
-        private bool isInitialized = false;
+        _outlookChangeProcessor = outlookChangeProcessor;
+        _gmailChangeProcessor = gmailChangeProcessor;
+        _imapChangeProcessor = imapChangeProcessor;
+        _outlookAuthenticator = outlookAuthenticator;
+        _gmailAuthenticator = gmailAuthenticator;
+        _accountService = accountService;
+        _imapSynchronizationStrategyProvider = imapSynchronizationStrategyProvider;
+        _applicationConfiguration = applicationConfiguration;
+    }
 
-        private readonly IAccountService _accountService;
-        private readonly IImapSynchronizationStrategyProvider _imapSynchronizationStrategyProvider;
-        private readonly IApplicationConfiguration _applicationConfiguration;
-        private readonly IOutlookChangeProcessor _outlookChangeProcessor;
-        private readonly IGmailChangeProcessor _gmailChangeProcessor;
-        private readonly IImapChangeProcessor _imapChangeProcessor;
-        private readonly IOutlookAuthenticator _outlookAuthenticator;
-        private readonly IGmailAuthenticator _gmailAuthenticator;
+    public async Task<IWinoSynchronizerBase> GetAccountSynchronizerAsync(Guid accountId)
+    {
+        var synchronizer = synchronizerCache.Find(a => a.Account.Id == accountId);
 
-        private readonly List<IWinoSynchronizerBase> synchronizerCache = new();
-
-        public SynchronizerFactory(IOutlookChangeProcessor outlookChangeProcessor,
-                                   IGmailChangeProcessor gmailChangeProcessor,
-                                   IImapChangeProcessor imapChangeProcessor,
-                                   IOutlookAuthenticator outlookAuthenticator,
-                                   IGmailAuthenticator gmailAuthenticator,
-                                   IAccountService accountService,
-                                   IImapSynchronizationStrategyProvider imapSynchronizationStrategyProvider,
-                                   IApplicationConfiguration applicationConfiguration)
+        if (synchronizer == null)
         {
-            _outlookChangeProcessor = outlookChangeProcessor;
-            _gmailChangeProcessor = gmailChangeProcessor;
-            _imapChangeProcessor = imapChangeProcessor;
-            _outlookAuthenticator = outlookAuthenticator;
-            _gmailAuthenticator = gmailAuthenticator;
-            _accountService = accountService;
-            _imapSynchronizationStrategyProvider = imapSynchronizationStrategyProvider;
-            _applicationConfiguration = applicationConfiguration;
+            var account = await _accountService.GetAccountAsync(accountId);
+
+            if (account != null)
+            {
+                synchronizer = CreateNewSynchronizer(account);
+
+
+                return await GetAccountSynchronizerAsync(accountId);
+            }
         }
 
-        public async Task<IWinoSynchronizerBase> GetAccountSynchronizerAsync(Guid accountId)
+        return synchronizer;
+    }
+
+    private IWinoSynchronizerBase CreateIntegratorWithDefaultProcessor(MailAccount mailAccount)
+    {
+        var providerType = mailAccount.ProviderType;
+
+        switch (providerType)
         {
-            var synchronizer = synchronizerCache.Find(a => a.Account.Id == accountId);
-
-            if (synchronizer == null)
-            {
-                var account = await _accountService.GetAccountAsync(accountId);
-
-                if (account != null)
-                {
-                    synchronizer = CreateNewSynchronizer(account);
-
-
-                    return await GetAccountSynchronizerAsync(accountId);
-                }
-            }
-
-            return synchronizer;
+            case Domain.Enums.MailProviderType.Outlook:
+                return new OutlookSynchronizer(mailAccount, _outlookAuthenticator, _outlookChangeProcessor);
+            case Domain.Enums.MailProviderType.Gmail:
+                return new GmailSynchronizer(mailAccount, _gmailAuthenticator, _gmailChangeProcessor);
+            case Domain.Enums.MailProviderType.IMAP4:
+                return new ImapSynchronizer(mailAccount, _imapChangeProcessor, _imapSynchronizationStrategyProvider, _applicationConfiguration);
+            default:
+                break;
         }
 
-        private IWinoSynchronizerBase CreateIntegratorWithDefaultProcessor(MailAccount mailAccount)
+        return null;
+    }
+
+    public IWinoSynchronizerBase CreateNewSynchronizer(MailAccount account)
+    {
+        var synchronizer = CreateIntegratorWithDefaultProcessor(account);
+
+        if (synchronizer is IImapSynchronizer imapSynchronizer)
         {
-            var providerType = mailAccount.ProviderType;
-
-            switch (providerType)
-            {
-                case Domain.Enums.MailProviderType.Outlook:
-                    return new OutlookSynchronizer(mailAccount, _outlookAuthenticator, _outlookChangeProcessor);
-                case Domain.Enums.MailProviderType.Gmail:
-                    return new GmailSynchronizer(mailAccount, _gmailAuthenticator, _gmailChangeProcessor);
-                case Domain.Enums.MailProviderType.IMAP4:
-                    return new ImapSynchronizer(mailAccount, _imapChangeProcessor, _imapSynchronizationStrategyProvider, _applicationConfiguration);
-                default:
-                    break;
-            }
-
-            return null;
+            // Start the idle client for IMAP synchronizer.
+            _ = imapSynchronizer.StartIdleClientAsync();
         }
 
-        public IWinoSynchronizerBase CreateNewSynchronizer(MailAccount account)
+        synchronizerCache.Add(synchronizer);
+
+        return synchronizer;
+    }
+
+    public async Task InitializeAsync()
+    {
+        if (isInitialized) return;
+
+        var accounts = await _accountService.GetAccountsAsync();
+
+        foreach (var account in accounts)
         {
-            var synchronizer = CreateIntegratorWithDefaultProcessor(account);
-
-            if (synchronizer is IImapSynchronizer imapSynchronizer)
-            {
-                // Start the idle client for IMAP synchronizer.
-                _ = imapSynchronizer.StartIdleClientAsync();
-            }
-
-            synchronizerCache.Add(synchronizer);
-
-            return synchronizer;
+            CreateNewSynchronizer(account);
         }
 
-        public async Task InitializeAsync()
+        isInitialized = true;
+    }
+
+    public async Task DeleteSynchronizerAsync(Guid accountId)
+    {
+        var synchronizer = synchronizerCache.Find(a => a.Account.Id == accountId);
+
+        if (synchronizer != null)
         {
-            if (isInitialized) return;
+            // Stop the current synchronization.
+            await synchronizer.KillSynchronizerAsync();
 
-            var accounts = await _accountService.GetAccountsAsync();
-
-            foreach (var account in accounts)
-            {
-                CreateNewSynchronizer(account);
-            }
-
-            isInitialized = true;
-        }
-
-        public async Task DeleteSynchronizerAsync(Guid accountId)
-        {
-            var synchronizer = synchronizerCache.Find(a => a.Account.Id == accountId);
-
-            if (synchronizer != null)
-            {
-                // Stop the current synchronization.
-                await synchronizer.KillSynchronizerAsync();
-
-                synchronizerCache.Remove(synchronizer);
-            }
+            synchronizerCache.Remove(synchronizer);
         }
     }
 }