use file-scoped namespacing for users module

modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/AbpUsersAbstractionModule.cs

@@ -2,16 +2,15 @@
 using Volo.Abp.Modularity;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.Users
-{
-    //TODO: Consider to (somehow) move this to the framework to the same assemblily of ICurrentUser!
+namespace Volo.Abp.Users;
+
+//TODO: Consider to (somehow) move this to the framework to the same assemblily of ICurrentUser!
 
-    [DependsOn(
-        typeof(AbpMultiTenancyModule),
-        typeof(AbpEventBusModule)
-        )]
-    public class AbpUsersAbstractionModule : AbpModule
-    {
+[DependsOn(
+    typeof(AbpMultiTenancyModule),
+    typeof(AbpEventBusModule)
+    )]
+public class AbpUsersAbstractionModule : AbpModule
+{
 
-    }
 }

modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/IExternalUserLookupServiceProvider.cs

@@ -3,24 +3,23 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IExternalUserLookupServiceProvider
 {
-    public interface IExternalUserLookupServiceProvider
-    {
-        Task<IUserData> FindByIdAsync(Guid id, CancellationToken cancellationToken = default);
+    Task<IUserData> FindByIdAsync(Guid id, CancellationToken cancellationToken = default);
 
-        Task<IUserData> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default);
+    Task<IUserData> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default);
 
-        Task<List<IUserData>> SearchAsync(
-            string sorting = null,
-            string filter = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            CancellationToken cancellationToken = default);
+    Task<List<IUserData>> SearchAsync(
+        string sorting = null,
+        string filter = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        CancellationToken cancellationToken = default);
 
-        Task<long> GetCountAsync(
-            string filter = null,
-            CancellationToken cancellationToken = default
-        );
-    }
-}
+    Task<long> GetCountAsync(
+        string filter = null,
+        CancellationToken cancellationToken = default
+    );
+}

modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/IUserData.cs

@@ -1,28 +1,27 @@
 using System;
 using JetBrains.Annotations;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IUserData
 {
-    public interface IUserData
-    {
-        Guid Id { get; }
+    Guid Id { get; }
 
-        Guid? TenantId { get; }
+    Guid? TenantId { get; }
 
-        string UserName { get; }
+    string UserName { get; }
 
-        string Name { get; }
+    string Name { get; }
 
-        string Surname { get; }
+    string Surname { get; }
 
-        [CanBeNull]
-        string Email { get; }
+    [CanBeNull]
+    string Email { get; }
 
-        bool EmailConfirmed { get; }
+    bool EmailConfirmed { get; }
 
-        [CanBeNull]
-        string PhoneNumber { get; }
+    [CanBeNull]
+    string PhoneNumber { get; }
 
-        bool PhoneNumberConfirmed { get; }
-    }
-}
+    bool PhoneNumberConfirmed { get; }
+}

modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/UserData.cs

@@ -1,66 +1,65 @@
 using System;
 using JetBrains.Annotations;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public class UserData : IUserData
 {
-    public class UserData : IUserData
-    {
-        public Guid Id { get; set; }
+    public Guid Id { get; set; }
 
-        public Guid? TenantId { get; set; }
+    public Guid? TenantId { get; set; }
 
-        public string UserName { get; set; }
+    public string UserName { get; set; }
 
-        public string Name { get; set; }
+    public string Name { get; set; }
 
-        public string Surname { get; set; }
+    public string Surname { get; set; }
 
-        public string Email { get; set; }
+    public string Email { get; set; }
 
-        public bool EmailConfirmed { get; set; }
+    public bool EmailConfirmed { get; set; }
 
-        public string PhoneNumber { get; set; }
+    public string PhoneNumber { get; set; }
 
-        public bool PhoneNumberConfirmed { get; set; }
+    public bool PhoneNumberConfirmed { get; set; }
 
-        public UserData()
-        {
+    public UserData()
+    {
 
-        }
+    }
 
-        public UserData(IUserData userData)
-        {
-            Id = userData.Id;
-            UserName = userData.UserName;
-            Email = userData.Email;
-            Name = userData.Name;
-            Surname = userData.Surname;
-            EmailConfirmed = userData.EmailConfirmed;
-            PhoneNumber = userData.PhoneNumber;
-            PhoneNumberConfirmed = userData.PhoneNumberConfirmed;
-            TenantId = userData.TenantId;
-        }
+    public UserData(IUserData userData)
+    {
+        Id = userData.Id;
+        UserName = userData.UserName;
+        Email = userData.Email;
+        Name = userData.Name;
+        Surname = userData.Surname;
+        EmailConfirmed = userData.EmailConfirmed;
+        PhoneNumber = userData.PhoneNumber;
+        PhoneNumberConfirmed = userData.PhoneNumberConfirmed;
+        TenantId = userData.TenantId;
+    }
 
-        public UserData(
-            Guid id,
-            [NotNull] string userName,
-            [CanBeNull] string email = null,
-            [CanBeNull] string name = null,
-            [CanBeNull] string surname = null,
-            bool emailConfirmed = false,
-            [CanBeNull] string phoneNumber = null,
-            bool phoneNumberConfirmed = false,
-            Guid? tenantId = null)
-        {
-            Id = id;
-            UserName = userName;
-            Email = email;
-            Name = name;
-            Surname = surname;
-            EmailConfirmed = emailConfirmed;
-            PhoneNumber = phoneNumber;
-            PhoneNumberConfirmed = phoneNumberConfirmed;
-            TenantId = tenantId;
-        }
+    public UserData(
+        Guid id,
+        [NotNull] string userName,
+        [CanBeNull] string email = null,
+        [CanBeNull] string name = null,
+        [CanBeNull] string surname = null,
+        bool emailConfirmed = false,
+        [CanBeNull] string phoneNumber = null,
+        bool phoneNumberConfirmed = false,
+        Guid? tenantId = null)
+    {
+        Id = id;
+        UserName = userName;
+        Email = email;
+        Name = name;
+        Surname = surname;
+        EmailConfirmed = emailConfirmed;
+        PhoneNumber = phoneNumber;
+        PhoneNumberConfirmed = phoneNumberConfirmed;
+        TenantId = tenantId;
     }
-}
+}

modules/users/src/Volo.Abp.Users.Abstractions/Volo/Abp/Users/UserEto.cs

@@ -1,27 +1,26 @@
 using System;
 using Volo.Abp.EventBus;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+[EventName("Volo.Abp.Users.User")]
+public class UserEto : IUserData
 {
-    [EventName("Volo.Abp.Users.User")]
-    public class UserEto : IUserData
-    {
-        public Guid Id { get; set; }
+    public Guid Id { get; set; }
 
-        public Guid? TenantId { get; set; }
+    public Guid? TenantId { get; set; }
 
-        public string UserName { get; set; }
+    public string UserName { get; set; }
 
-        public string Name { get; set; }
+    public string Name { get; set; }
 
-        public string Surname { get; set; }
+    public string Surname { get; set; }
 
-        public string Email { get; set; }
+    public string Email { get; set; }
 
-        public bool EmailConfirmed { get; set; }
+    public bool EmailConfirmed { get; set; }
 
-        public string PhoneNumber { get; set; }
+    public string PhoneNumber { get; set; }
 
-        public bool PhoneNumberConfirmed { get; set; }
-    }
+    public bool PhoneNumberConfirmed { get; set; }
 }

modules/users/src/Volo.Abp.Users.Domain.Shared/Volo/Abp/Users/AbpUserConsts.cs

@@ -1,30 +1,29 @@
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public class AbpUserConsts
 {
-    public class AbpUserConsts
-    {
-        /// <summary>
-        /// Default value: 256
-        /// </summary>
-        public static int MaxUserNameLength { get; set; } = 256;
-        
-        /// <summary>
-        /// Default value: 64
-        /// </summary>
-        public static int MaxNameLength { get; set; } = 64;
-        
-        /// <summary>
-        /// Default value: 64
-        /// </summary>
-        public static int MaxSurnameLength { get; set; } = 64;
+    /// <summary>
+    /// Default value: 256
+    /// </summary>
+    public static int MaxUserNameLength { get; set; } = 256;
+
+    /// <summary>
+    /// Default value: 64
+    /// </summary>
+    public static int MaxNameLength { get; set; } = 64;
+
+    /// <summary>
+    /// Default value: 64
+    /// </summary>
+    public static int MaxSurnameLength { get; set; } = 64;
 
-        /// <summary>
-        /// Default value: 256
-        /// </summary>
-        public static int MaxEmailLength { get; set; } = 256;
+    /// <summary>
+    /// Default value: 256
+    /// </summary>
+    public static int MaxEmailLength { get; set; } = 256;
 
-        /// <summary>
-        /// Default value: 16
-        /// </summary>
-        public static int MaxPhoneNumberLength { get; set; } = 16;
-    }
-}
+    /// <summary>
+    /// Default value: 16
+    /// </summary>
+    public static int MaxPhoneNumberLength { get; set; } = 16;
+}

modules/users/src/Volo.Abp.Users.Domain.Shared/Volo/Abp/Users/AbpUsersDomainSharedModule.cs

@@ -1,9 +1,8 @@
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public class AbpUsersDomainSharedModule : AbpModule
 {
-    public class AbpUsersDomainSharedModule : AbpModule
-    {
-        
-    }
+
 }

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/AbpUserExtensions.cs

@@ -1,20 +1,19 @@
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public static class AbpUserExtensions
 {
-    public static class AbpUserExtensions
+    public static IUserData ToAbpUserData(this IUser user)
     {
-        public static IUserData ToAbpUserData(this IUser user)
-        {
-            return new UserData(
-                id: user.Id,
-                userName: user.UserName,
-                email: user.Email,
-                name: user.Name,
-                surname: user.Surname,
-                emailConfirmed: user.EmailConfirmed,
-                phoneNumber: user.PhoneNumber,
-                phoneNumberConfirmed: user.PhoneNumberConfirmed,
-                tenantId: user.TenantId
-            );
-        }
+        return new UserData(
+            id: user.Id,
+            userName: user.UserName,
+            email: user.Email,
+            name: user.Name,
+            surname: user.Surname,
+            emailConfirmed: user.EmailConfirmed,
+            phoneNumber: user.PhoneNumber,
+            phoneNumberConfirmed: user.PhoneNumberConfirmed,
+            tenantId: user.TenantId
+        );
     }
-}
+}

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/AbpUsersDomainModule.cs

@@ -1,15 +1,14 @@
 using Volo.Abp.Domain;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+[DependsOn(
+    typeof(AbpUsersDomainSharedModule),
+    typeof(AbpUsersAbstractionModule),
+    typeof(AbpDddDomainModule)
+    )]
+public class AbpUsersDomainModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpUsersDomainSharedModule),
-        typeof(AbpUsersAbstractionModule),
-        typeof(AbpDddDomainModule)
-        )]
-    public class AbpUsersDomainModule : AbpModule
-    {
-        
-    }
+
 }

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/IUpdateUserData.cs

@@ -1,9 +1,8 @@
 using JetBrains.Annotations;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IUpdateUserData
 {
-    public interface IUpdateUserData
-    {
-        bool Update([NotNull] IUserData user);
-    }
-}
+    bool Update([NotNull] IUserData user);
+}

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/IUser.cs

@@ -3,26 +3,25 @@ using JetBrains.Annotations;
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.MultiTenancy;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IUser : IAggregateRoot<Guid>, IMultiTenant
 {
-    public interface IUser : IAggregateRoot<Guid>, IMultiTenant
-    {
-        string UserName { get; }
+    string UserName { get; }
 
-        [CanBeNull]
-        string Email { get; }
+    [CanBeNull]
+    string Email { get; }
 
-        [CanBeNull]
-        string Name  { get; }
+    [CanBeNull]
+    string Name { get; }
 
-        [CanBeNull]
-        string Surname { get; }
+    [CanBeNull]
+    string Surname { get; }
 
-        bool EmailConfirmed { get; }
+    bool EmailConfirmed { get; }
 
-        [CanBeNull]
-        string PhoneNumber { get; }
+    [CanBeNull]
+    string PhoneNumber { get; }
 
-        bool PhoneNumberConfirmed { get; }
-    }
-}
+    bool PhoneNumberConfirmed { get; }
+}

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/IUserLookupService.cs

@@ -3,30 +3,29 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IUserLookupService<TUser>
+    where TUser : class, IUser
 {
-    public interface IUserLookupService<TUser>
-        where TUser : class, IUser
-    {
-        Task<TUser> FindByIdAsync(
-            Guid id,
-            CancellationToken cancellationToken = default
-        );
+    Task<TUser> FindByIdAsync(
+        Guid id,
+        CancellationToken cancellationToken = default
+    );
 
-        Task<TUser> FindByUserNameAsync(
-            string userName,
-            CancellationToken cancellationToken = default
-        );
+    Task<TUser> FindByUserNameAsync(
+        string userName,
+        CancellationToken cancellationToken = default
+    );
 
-        Task<List<IUserData>> SearchAsync(
-            string sorting = null,
-            string filter = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            CancellationToken cancellationToken = default);
+    Task<List<IUserData>> SearchAsync(
+        string sorting = null,
+        string filter = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        CancellationToken cancellationToken = default);
 
-        Task<long> GetCountAsync(
-            string filter = null,
-            CancellationToken cancellationToken = default);
-    }
+    Task<long> GetCountAsync(
+        string filter = null,
+        CancellationToken cancellationToken = default);
 }

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/IUserRepository.cs

@@ -5,25 +5,24 @@ using System.Threading.Tasks;
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.Domain.Repositories;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public interface IUserRepository<TUser> : IBasicRepository<TUser, Guid>
+    where TUser : class, IUser, IAggregateRoot<Guid>
 {
-    public interface IUserRepository<TUser> : IBasicRepository<TUser, Guid>
-        where TUser : class, IUser, IAggregateRoot<Guid>
-    {
-        Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default);
+    Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default);
 
-        Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default);
+    Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default);
 
-        Task<List<TUser>> SearchAsync(
-            string sorting = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            string filter = null,
-            CancellationToken cancellationToken = default
-        );
+    Task<List<TUser>> SearchAsync(
+        string sorting = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        string filter = null,
+        CancellationToken cancellationToken = default
+    );
 
-        Task<long> GetCountAsync(
-            string filter = null,
-            CancellationToken cancellationToken = default);
-    }
-}
+    Task<long> GetCountAsync(
+        string filter = null,
+        CancellationToken cancellationToken = default);
+}

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/UserLookupService.cs

@@ -8,200 +8,199 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Uow;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public abstract class UserLookupService<TUser, TUserRepository> : IUserLookupService<TUser>, ITransientDependency
+    where TUser : class, IUser
+    where TUserRepository : IUserRepository<TUser>
 {
-    public abstract class UserLookupService<TUser, TUserRepository> : IUserLookupService<TUser>, ITransientDependency
-        where TUser : class, IUser
-        where TUserRepository : IUserRepository<TUser>
+    protected bool SkipExternalLookupIfLocalUserExists { get; set; } = true;
+
+    public IExternalUserLookupServiceProvider ExternalUserLookupServiceProvider { get; set; }
+    public ILogger<UserLookupService<TUser, TUserRepository>> Logger { get; set; }
+
+    private readonly TUserRepository _userRepository;
+    private readonly IUnitOfWorkManager _unitOfWorkManager;
+
+    protected UserLookupService(
+        TUserRepository userRepository,
+        IUnitOfWorkManager unitOfWorkManager)
     {
-        protected bool SkipExternalLookupIfLocalUserExists { get; set; } = true;
+        _userRepository = userRepository;
+        _unitOfWorkManager = unitOfWorkManager;
 
-        public IExternalUserLookupServiceProvider ExternalUserLookupServiceProvider { get; set; }
-        public ILogger<UserLookupService<TUser, TUserRepository>> Logger { get; set; }
+        Logger = NullLogger<UserLookupService<TUser, TUserRepository>>.Instance;
+    }
 
-        private readonly TUserRepository _userRepository;
-        private readonly IUnitOfWorkManager _unitOfWorkManager;
+    public async Task<TUser> FindByIdAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        var localUser = await _userRepository.FindAsync(id, cancellationToken: cancellationToken);
 
-        protected UserLookupService(
-            TUserRepository userRepository,
-            IUnitOfWorkManager unitOfWorkManager)
+        if (ExternalUserLookupServiceProvider == null)
         {
-            _userRepository = userRepository;
-            _unitOfWorkManager = unitOfWorkManager;
-
-            Logger = NullLogger<UserLookupService<TUser, TUserRepository>>.Instance;
+            return localUser;
         }
 
-        public async Task<TUser> FindByIdAsync(Guid id, CancellationToken cancellationToken = default)
+        if (SkipExternalLookupIfLocalUserExists && localUser != null)
         {
-            var localUser = await _userRepository.FindAsync(id, cancellationToken: cancellationToken);
-
-            if (ExternalUserLookupServiceProvider == null)
-            {
-                return localUser;
-            }
-
-            if (SkipExternalLookupIfLocalUserExists && localUser != null)
-            {
-                return localUser;
-            }
+            return localUser;
+        }
 
-            IUserData externalUser;
+        IUserData externalUser;
 
-            try
+        try
+        {
+            externalUser = await ExternalUserLookupServiceProvider.FindByIdAsync(id, cancellationToken);
+            if (externalUser == null)
             {
-                externalUser = await ExternalUserLookupServiceProvider.FindByIdAsync(id, cancellationToken);
-                if (externalUser == null)
+                if (localUser != null)
                 {
-                    if (localUser != null)
-                    {
-                        //TODO: Instead of deleting, should be make it inactive or something like that?
-                        await WithNewUowAsync(() => _userRepository.DeleteAsync(localUser, cancellationToken: cancellationToken));
-                    }
-
-                    return null;
+                    //TODO: Instead of deleting, should be make it inactive or something like that?
+                    await WithNewUowAsync(() => _userRepository.DeleteAsync(localUser, cancellationToken: cancellationToken));
                 }
-            }
-            catch (Exception ex)
-            {
-                Logger.LogException(ex);
-                return localUser;
-            }
 
-            if (localUser == null)
-            {
-                await WithNewUowAsync(() => _userRepository.InsertAsync(CreateUser(externalUser), cancellationToken: cancellationToken));
-                return await _userRepository.FindAsync(id, cancellationToken: cancellationToken);
-            }
-
-            if (localUser is IUpdateUserData && ((IUpdateUserData)localUser).Update(externalUser))
-            {
-                await WithNewUowAsync(() => _userRepository.UpdateAsync(localUser, cancellationToken: cancellationToken));
-            }
-            else
-            {
-                return localUser;
+                return null;
             }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogException(ex);
+            return localUser;
+        }
 
+        if (localUser == null)
+        {
+            await WithNewUowAsync(() => _userRepository.InsertAsync(CreateUser(externalUser), cancellationToken: cancellationToken));
             return await _userRepository.FindAsync(id, cancellationToken: cancellationToken);
         }
 
-        public async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
+        if (localUser is IUpdateUserData && ((IUpdateUserData)localUser).Update(externalUser))
+        {
+            await WithNewUowAsync(() => _userRepository.UpdateAsync(localUser, cancellationToken: cancellationToken));
+        }
+        else
         {
-            var localUser = await _userRepository.FindByUserNameAsync(userName, cancellationToken);
+            return localUser;
+        }
 
-            if (ExternalUserLookupServiceProvider == null)
-            {
-                return localUser;
-            }
+        return await _userRepository.FindAsync(id, cancellationToken: cancellationToken);
+    }
 
-            if (SkipExternalLookupIfLocalUserExists && localUser != null)
-            {
-                return localUser;
-            }
+    public async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
+    {
+        var localUser = await _userRepository.FindByUserNameAsync(userName, cancellationToken);
 
-            IUserData externalUser;
+        if (ExternalUserLookupServiceProvider == null)
+        {
+            return localUser;
+        }
 
-            try
-            {
-                externalUser = await ExternalUserLookupServiceProvider.FindByUserNameAsync(userName, cancellationToken);
-                if (externalUser == null)
-                {
-                    if (localUser != null)
-                    {
-                        //TODO: Instead of deleting, should be make it passive or something like that?
-                        await WithNewUowAsync(() => _userRepository.DeleteAsync(localUser, cancellationToken: cancellationToken));
-                    }
+        if (SkipExternalLookupIfLocalUserExists && localUser != null)
+        {
+            return localUser;
+        }
 
-                    return null;
-                }
-            }
-            catch (Exception ex)
-            {
-                Logger.LogException(ex);
-                return localUser;
-            }
+        IUserData externalUser;
 
-            if (localUser == null)
+        try
+        {
+            externalUser = await ExternalUserLookupServiceProvider.FindByUserNameAsync(userName, cancellationToken);
+            if (externalUser == null)
             {
-                await WithNewUowAsync(() => _userRepository.InsertAsync(CreateUser(externalUser), cancellationToken: cancellationToken));
-                return await _userRepository.FindAsync(externalUser.Id, cancellationToken: cancellationToken);
-            }
+                if (localUser != null)
+                {
+                    //TODO: Instead of deleting, should be make it passive or something like that?
+                    await WithNewUowAsync(() => _userRepository.DeleteAsync(localUser, cancellationToken: cancellationToken));
+                }
 
-            if (localUser is IUpdateUserData && ((IUpdateUserData)localUser).Update(externalUser))
-            {
-                await WithNewUowAsync(() => _userRepository.UpdateAsync(localUser, cancellationToken: cancellationToken));
-            }
-            else
-            {
-                return localUser;
+                return null;
             }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogException(ex);
+            return localUser;
+        }
 
+        if (localUser == null)
+        {
+            await WithNewUowAsync(() => _userRepository.InsertAsync(CreateUser(externalUser), cancellationToken: cancellationToken));
             return await _userRepository.FindAsync(externalUser.Id, cancellationToken: cancellationToken);
         }
 
-        public async Task<List<IUserData>> SearchAsync(
-            string sorting = null,
-            string filter = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            CancellationToken cancellationToken = default)
+        if (localUser is IUpdateUserData && ((IUpdateUserData)localUser).Update(externalUser))
         {
-            if (ExternalUserLookupServiceProvider != null)
-            {
-                return await ExternalUserLookupServiceProvider
-                    .SearchAsync(
-                        sorting,
-                        filter,
-                        maxResultCount,
-                        skipCount,
-                        cancellationToken
-                    );
-            }
+            await WithNewUowAsync(() => _userRepository.UpdateAsync(localUser, cancellationToken: cancellationToken));
+        }
+        else
+        {
+            return localUser;
+        }
 
-            var localUsers = await _userRepository
+        return await _userRepository.FindAsync(externalUser.Id, cancellationToken: cancellationToken);
+    }
+
+    public async Task<List<IUserData>> SearchAsync(
+        string sorting = null,
+        string filter = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        CancellationToken cancellationToken = default)
+    {
+        if (ExternalUserLookupServiceProvider != null)
+        {
+            return await ExternalUserLookupServiceProvider
                 .SearchAsync(
                     sorting,
+                    filter,
                     maxResultCount,
                     skipCount,
-                    filter,
                     cancellationToken
                 );
-
-            return localUsers
-                .Cast<IUserData>()
-                .ToList();
         }
 
-        public async Task<long> GetCountAsync(
-            string filter = null,
-            CancellationToken cancellationToken = default)
-        {
-            if (ExternalUserLookupServiceProvider != null)
-            {
-                return await ExternalUserLookupServiceProvider
-                    .GetCountAsync(
-                        filter,
-                        cancellationToken
-                    );
-            }
+        var localUsers = await _userRepository
+            .SearchAsync(
+                sorting,
+                maxResultCount,
+                skipCount,
+                filter,
+                cancellationToken
+            );
+
+        return localUsers
+            .Cast<IUserData>()
+            .ToList();
+    }
 
-            return await _userRepository
+    public async Task<long> GetCountAsync(
+        string filter = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (ExternalUserLookupServiceProvider != null)
+        {
+            return await ExternalUserLookupServiceProvider
                 .GetCountAsync(
                     filter,
                     cancellationToken
                 );
         }
 
-        protected abstract TUser CreateUser(IUserData externalUser);
+        return await _userRepository
+            .GetCountAsync(
+                filter,
+                cancellationToken
+            );
+    }
+
+    protected abstract TUser CreateUser(IUserData externalUser);
 
-        private async Task WithNewUowAsync(Func<Task> func)
+    private async Task WithNewUowAsync(Func<Task> func)
+    {
+        using (var uow = _unitOfWorkManager.Begin(requiresNew: true))
         {
-            using (var uow = _unitOfWorkManager.Begin(requiresNew: true))
-            {
-                await func();
-                await uow.CompleteAsync();
-            }
+            await func();
+            await uow.CompleteAsync();
         }
     }
 }

modules/users/src/Volo.Abp.Users.Domain/Volo/Abp/Users/UserLookupServiceExtensions.cs

@@ -3,32 +3,31 @@ using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Entities;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+public static class UserLookupServiceExtensions
 {
-    public static class UserLookupServiceExtensions
+    public static async Task<TUser> GetByIdAsync<TUser>(this IUserLookupService<TUser> userLookupService, Guid id, CancellationToken cancellationToken = default)
+        where TUser : class, IUser
     {
-        public static async Task<TUser> GetByIdAsync<TUser>(this IUserLookupService<TUser> userLookupService, Guid id, CancellationToken cancellationToken = default)
-            where TUser : class, IUser
+        var user = await userLookupService.FindByIdAsync(id, cancellationToken);
+        if (user == null)
         {
-            var user = await userLookupService.FindByIdAsync(id, cancellationToken);
-            if (user == null)
-            {
-                throw new EntityNotFoundException(typeof(TUser), id);
-            }
-
-            return user;
+            throw new EntityNotFoundException(typeof(TUser), id);
         }
 
-        public static async Task<TUser> GetByUserNameAsync<TUser>(this IUserLookupService<TUser> userLookupService, string userName, CancellationToken cancellationToken = default)
-            where TUser : class, IUser
-        {
-            var user = await userLookupService.FindByUserNameAsync(userName, cancellationToken);
-            if (user == null)
-            {
-                throw new EntityNotFoundException(typeof(TUser), userName);
-            }
+        return user;
+    }
 
-            return user;
+    public static async Task<TUser> GetByUserNameAsync<TUser>(this IUserLookupService<TUser> userLookupService, string userName, CancellationToken cancellationToken = default)
+        where TUser : class, IUser
+    {
+        var user = await userLookupService.FindByUserNameAsync(userName, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException(typeof(TUser), userName);
         }
+
+        return user;
     }
-}
+}

modules/users/src/Volo.Abp.Users.EntityFrameworkCore/Volo/Abp/Users/EntityFrameworkCore/AbpUsersDbContextModelCreatingExtensions.cs

@@ -1,21 +1,20 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace Volo.Abp.Users.EntityFrameworkCore
+namespace Volo.Abp.Users.EntityFrameworkCore;
+
+public static class AbpUsersDbContextModelCreatingExtensions
 {
-    public static class AbpUsersDbContextModelCreatingExtensions
+    public static void ConfigureAbpUser<TUser>(this EntityTypeBuilder<TUser> b)
+        where TUser : class, IUser
     {
-        public static void ConfigureAbpUser<TUser>(this EntityTypeBuilder<TUser> b)
-            where TUser : class, IUser
-        {
-            b.Property(u => u.TenantId).HasColumnName(nameof(IUser.TenantId));
-            b.Property(u => u.UserName).IsRequired().HasMaxLength(AbpUserConsts.MaxUserNameLength).HasColumnName(nameof(IUser.UserName));
-            b.Property(u => u.Email).IsRequired().HasMaxLength(AbpUserConsts.MaxEmailLength).HasColumnName(nameof(IUser.Email));
-            b.Property(u => u.Name).HasMaxLength(AbpUserConsts.MaxNameLength).HasColumnName(nameof(IUser.Name));
-            b.Property(u => u.Surname).HasMaxLength(AbpUserConsts.MaxSurnameLength).HasColumnName(nameof(IUser.Surname));
-            b.Property(u => u.EmailConfirmed).HasDefaultValue(false).HasColumnName(nameof(IUser.EmailConfirmed));
-            b.Property(u => u.PhoneNumber).HasMaxLength(AbpUserConsts.MaxPhoneNumberLength).HasColumnName(nameof(IUser.PhoneNumber));
-            b.Property(u => u.PhoneNumberConfirmed).HasDefaultValue(false).HasColumnName(nameof(IUser.PhoneNumberConfirmed));
-        }
+        b.Property(u => u.TenantId).HasColumnName(nameof(IUser.TenantId));
+        b.Property(u => u.UserName).IsRequired().HasMaxLength(AbpUserConsts.MaxUserNameLength).HasColumnName(nameof(IUser.UserName));
+        b.Property(u => u.Email).IsRequired().HasMaxLength(AbpUserConsts.MaxEmailLength).HasColumnName(nameof(IUser.Email));
+        b.Property(u => u.Name).HasMaxLength(AbpUserConsts.MaxNameLength).HasColumnName(nameof(IUser.Name));
+        b.Property(u => u.Surname).HasMaxLength(AbpUserConsts.MaxSurnameLength).HasColumnName(nameof(IUser.Surname));
+        b.Property(u => u.EmailConfirmed).HasDefaultValue(false).HasColumnName(nameof(IUser.EmailConfirmed));
+        b.Property(u => u.PhoneNumber).HasMaxLength(AbpUserConsts.MaxPhoneNumberLength).HasColumnName(nameof(IUser.PhoneNumber));
+        b.Property(u => u.PhoneNumberConfirmed).HasDefaultValue(false).HasColumnName(nameof(IUser.PhoneNumberConfirmed));
     }
-}
+}

modules/users/src/Volo.Abp.Users.EntityFrameworkCore/Volo/Abp/Users/EntityFrameworkCore/AbpUsersEntityFrameworkCoreModule.cs

@@ -1,14 +1,13 @@
 using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.Modularity;
 
-namespace Volo.Abp.Users.EntityFrameworkCore
+namespace Volo.Abp.Users.EntityFrameworkCore;
+
+[DependsOn(
+    typeof(AbpUsersDomainModule),
+    typeof(AbpEntityFrameworkCoreModule)
+    )]
+public class AbpUsersEntityFrameworkCoreModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpUsersDomainModule),
-        typeof(AbpEntityFrameworkCoreModule)
-        )]
-    public class AbpUsersEntityFrameworkCoreModule : AbpModule
-    {
-        
-    }
+
 }

modules/users/src/Volo.Abp.Users.EntityFrameworkCore/Volo/Abp/Users/EntityFrameworkCore/EfCoreAbpUserRepositoryBase.cs

@@ -8,65 +8,64 @@ using Microsoft.EntityFrameworkCore;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
 
-namespace Volo.Abp.Users.EntityFrameworkCore
+namespace Volo.Abp.Users.EntityFrameworkCore;
+
+public abstract class EfCoreUserRepositoryBase<TDbContext, TUser> : EfCoreRepository<TDbContext, TUser, Guid>, IUserRepository<TUser>
+    where TDbContext : IEfCoreDbContext
+    where TUser : class, IUser
 {
-    public abstract class EfCoreUserRepositoryBase<TDbContext, TUser> : EfCoreRepository<TDbContext, TUser, Guid>, IUserRepository<TUser>
-        where TDbContext : IEfCoreDbContext
-        where TUser : class, IUser
+    protected EfCoreUserRepositoryBase(IDbContextProvider<TDbContext> dbContextProvider)
+        : base(dbContextProvider)
     {
-        protected EfCoreUserRepositoryBase(IDbContextProvider<TDbContext> dbContextProvider)
-            : base(dbContextProvider)
-        {
 
-        }
+    }
 
-        public async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync()).OrderBy(x => x.Id).FirstOrDefaultAsync(u => u.UserName == userName, GetCancellationToken(cancellationToken));
-        }
+    public async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync()).OrderBy(x => x.Id).FirstOrDefaultAsync(u => u.UserName == userName, GetCancellationToken(cancellationToken));
+    }
 
-        public virtual async Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .Where(u => ids.Contains(u.Id))
-                .ToListAsync(GetCancellationToken(cancellationToken));
-        }
+    public virtual async Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(u => ids.Contains(u.Id))
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 
-        public async Task<List<TUser>> SearchAsync(
-            string sorting = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            string filter = null,
-            CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .WhereIf(
-                    !filter.IsNullOrWhiteSpace(),
-                    u =>
-                        u.UserName.Contains(filter) ||
-                        (u.Email != null && u.Email.Contains(filter)) ||
-                        (u.Name != null && u.Name.Contains(filter)) ||
-                        (u.Surname != null && u.Surname.Contains(filter))
-                )
-                .OrderBy(sorting.IsNullOrEmpty() ? nameof(IUser.UserName) : sorting)
-                .PageBy(skipCount, maxResultCount)
-                .ToListAsync(GetCancellationToken(cancellationToken));
-        }
+    public async Task<List<TUser>> SearchAsync(
+        string sorting = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        string filter = null,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .WhereIf(
+                !filter.IsNullOrWhiteSpace(),
+                u =>
+                    u.UserName.Contains(filter) ||
+                    (u.Email != null && u.Email.Contains(filter)) ||
+                    (u.Name != null && u.Name.Contains(filter)) ||
+                    (u.Surname != null && u.Surname.Contains(filter))
+            )
+            .OrderBy(sorting.IsNullOrEmpty() ? nameof(IUser.UserName) : sorting)
+            .PageBy(skipCount, maxResultCount)
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 
-        public async Task<long> GetCountAsync(
-            string filter = null,
-            CancellationToken cancellationToken = default)
-        {
-            return await (await GetDbSetAsync())
-                .WhereIf(
-                    !filter.IsNullOrWhiteSpace(),
-                    u =>
-                        u.UserName.Contains(filter) ||
-                        (u.Email != null && u.Email.Contains(filter)) ||
-                        (u.Name != null && u.Name.Contains(filter)) ||
-                        (u.Surname != null && u.Surname.Contains(filter))
-                )
-                .LongCountAsync(GetCancellationToken(cancellationToken));
-        }
+    public async Task<long> GetCountAsync(
+        string filter = null,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .WhereIf(
+                !filter.IsNullOrWhiteSpace(),
+                u =>
+                    u.UserName.Contains(filter) ||
+                    (u.Email != null && u.Email.Contains(filter)) ||
+                    (u.Name != null && u.Name.Contains(filter)) ||
+                    (u.Surname != null && u.Surname.Contains(filter))
+            )
+            .LongCountAsync(GetCancellationToken(cancellationToken));
     }
 }

modules/users/src/Volo.Abp.Users.Installer/Volo/Abp/Users/AbpUsersInstallerModule.cs

@@ -2,20 +2,19 @@
 using Volo.Abp.Studio;
 using Volo.Abp.VirtualFileSystem;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+[DependsOn(
+    typeof(AbpStudioModuleInstallerModule),
+    typeof(AbpVirtualFileSystemModule)
+    )]
+public class AbpUsersInstallerModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpStudioModuleInstallerModule),
-        typeof(AbpVirtualFileSystemModule)
-        )]
-    public class AbpUsersInstallerModule : AbpModule
+    public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        public override void ConfigureServices(ServiceConfigurationContext context)
+        Configure<AbpVirtualFileSystemOptions>(options =>
         {
-            Configure<AbpVirtualFileSystemOptions>(options =>
-            {
-                options.FileSets.AddEmbedded<AbpUsersInstallerModule>();
-            });
-        }
+            options.FileSets.AddEmbedded<AbpUsersInstallerModule>();
+        });
     }
 }

modules/users/src/Volo.Abp.Users.Installer/Volo/Abp/Users/UsersInstallerPipelineBuilder.cs

@@ -3,22 +3,21 @@ using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Studio.ModuleInstalling;
 
-namespace Volo.Abp.Users
+namespace Volo.Abp.Users;
+
+[Dependency(ServiceLifetime.Transient, ReplaceServices = true)]
+[ExposeServices(typeof(IModuleInstallingPipelineBuilder))]
+public class UsersInstallerPipelineBuilder : ModuleInstallingPipelineBuilderBase, IModuleInstallingPipelineBuilder, ITransientDependency
 {
-    [Dependency(ServiceLifetime.Transient, ReplaceServices = true)]
-    [ExposeServices(typeof(IModuleInstallingPipelineBuilder))]
-    public class UsersInstallerPipelineBuilder : ModuleInstallingPipelineBuilderBase, IModuleInstallingPipelineBuilder, ITransientDependency
+    public async Task<ModuleInstallingPipeline> BuildAsync(ModuleInstallingContext context)
     {
-        public async Task<ModuleInstallingPipeline> BuildAsync(ModuleInstallingContext context)
-        {
-            context.AddEfCoreConfigurationMethodDeclaration(
-                new EfCoreConfigurationMethodDeclaration(
-                    "Volo.Abp.Users.EntityFrameworkCore",
-                    "ConfigureAbpUser"
-                )
-            );
-            
-            return GetBasePipeline(context);
-        }
+        context.AddEfCoreConfigurationMethodDeclaration(
+            new EfCoreConfigurationMethodDeclaration(
+                "Volo.Abp.Users.EntityFrameworkCore",
+                "ConfigureAbpUser"
+            )
+        );
+
+        return GetBasePipeline(context);
     }
 }

modules/users/src/Volo.Abp.Users.MongoDB/Volo/Abp/Users/MongoDB/AbpUsersMongoDbModule.cs

@@ -1,14 +1,13 @@
 using Volo.Abp.Modularity;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.Users.MongoDB
+namespace Volo.Abp.Users.MongoDB;
+
+[DependsOn(
+    typeof(AbpUsersDomainModule),
+    typeof(AbpMongoDbModule)
+    )]
+public class AbpUsersMongoDbModule : AbpModule
 {
-    [DependsOn(
-        typeof(AbpUsersDomainModule),
-        typeof(AbpMongoDbModule)
-        )]
-    public class AbpUsersMongoDbModule : AbpModule
-    {
-        
-    }
+
 }

modules/users/src/Volo.Abp.Users.MongoDB/Volo/Abp/Users/MongoDB/MongoUserRepositoryBase.cs

@@ -9,70 +9,69 @@ using MongoDB.Driver.Linq;
 using Volo.Abp.Domain.Repositories.MongoDB;
 using Volo.Abp.MongoDB;
 
-namespace Volo.Abp.Users.MongoDB
+namespace Volo.Abp.Users.MongoDB;
+
+public abstract class MongoUserRepositoryBase<TDbContext, TUser> : MongoDbRepository<TDbContext, TUser, Guid>, IUserRepository<TUser>
+    where TDbContext : IAbpMongoDbContext
+    where TUser : class, IUser
 {
-    public abstract class MongoUserRepositoryBase<TDbContext, TUser> : MongoDbRepository<TDbContext, TUser, Guid>, IUserRepository<TUser>
-        where TDbContext : IAbpMongoDbContext
-        where TUser : class, IUser
+    protected MongoUserRepositoryBase(IMongoDbContextProvider<TDbContext> dbContextProvider)
+        : base(dbContextProvider)
     {
-        protected MongoUserRepositoryBase(IMongoDbContextProvider<TDbContext> dbContextProvider)
-            : base(dbContextProvider)
-        {
 
-        }
+    }
 
-        public virtual async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .OrderBy(x => x.Id)
-                .FirstOrDefaultAsync(u => u.UserName == userName, cancellationToken);
-        }
+    public virtual async Task<TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .OrderBy(x => x.Id)
+            .FirstOrDefaultAsync(u => u.UserName == userName, cancellationToken);
+    }
 
-        public virtual async Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .Where(u => ids.Contains(u.Id))
-                .ToListAsync(cancellationToken);
-        }
+    public virtual async Task<List<TUser>> GetListAsync(IEnumerable<Guid> ids, CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .Where(u => ids.Contains(u.Id))
+            .ToListAsync(cancellationToken);
+    }
 
-        public async Task<List<TUser>> SearchAsync(
-            string sorting = null,
-            int maxResultCount = int.MaxValue,
-            int skipCount = 0,
-            string filter = null,
-            CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .WhereIf<TUser, IMongoQueryable<TUser>>(
-                    !filter.IsNullOrWhiteSpace(),
-                    u =>
-                        u.UserName.Contains(filter) ||
-                        (u.Email != null && u.Email.Contains(filter)) ||
-                        (u.Name != null && u.Name.Contains(filter)) ||
-                        (u.Surname != null && u.Surname.Contains(filter))
-                )
-                .OrderBy(sorting.IsNullOrEmpty() ? nameof(IUserData.UserName) : sorting)
-                .As<IMongoQueryable<TUser>>()
-                .PageBy<TUser, IMongoQueryable<TUser>>(skipCount, maxResultCount)
-                .ToListAsync(cancellationToken);
-        }
+    public async Task<List<TUser>> SearchAsync(
+        string sorting = null,
+        int maxResultCount = int.MaxValue,
+        int skipCount = 0,
+        string filter = null,
+        CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .WhereIf<TUser, IMongoQueryable<TUser>>(
+                !filter.IsNullOrWhiteSpace(),
+                u =>
+                    u.UserName.Contains(filter) ||
+                    (u.Email != null && u.Email.Contains(filter)) ||
+                    (u.Name != null && u.Name.Contains(filter)) ||
+                    (u.Surname != null && u.Surname.Contains(filter))
+            )
+            .OrderBy(sorting.IsNullOrEmpty() ? nameof(IUserData.UserName) : sorting)
+            .As<IMongoQueryable<TUser>>()
+            .PageBy<TUser, IMongoQueryable<TUser>>(skipCount, maxResultCount)
+            .ToListAsync(cancellationToken);
+    }
 
-        public async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
-        {
-            cancellationToken = GetCancellationToken(cancellationToken);
-            return await (await GetMongoQueryableAsync(cancellationToken))
-                .WhereIf<TUser, IMongoQueryable<TUser>>(
-                    !filter.IsNullOrWhiteSpace(),
-                    u =>
-                        u.UserName.Contains(filter) ||
-                        (u.Email != null && u.Email.Contains(filter)) ||
-                        (u.Name != null && u.Name.Contains(filter)) ||
-                        (u.Surname != null && u.Surname.Contains(filter))
-                )
-                .LongCountAsync(cancellationToken);
-        }
+    public async Task<long> GetCountAsync(string filter = null, CancellationToken cancellationToken = default)
+    {
+        cancellationToken = GetCancellationToken(cancellationToken);
+        return await (await GetMongoQueryableAsync(cancellationToken))
+            .WhereIf<TUser, IMongoQueryable<TUser>>(
+                !filter.IsNullOrWhiteSpace(),
+                u =>
+                    u.UserName.Contains(filter) ||
+                    (u.Email != null && u.Email.Contains(filter)) ||
+                    (u.Name != null && u.Name.Contains(filter)) ||
+                    (u.Surname != null && u.Surname.Contains(filter))
+            )
+            .LongCountAsync(cancellationToken);
     }
 }