Exemple #1
0
    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,
                       cancellationToken
                       ));
        }

        var localUsers = await _userRepository
                         .SearchAsync(
            sorting,
            maxResultCount,
            skipCount,
            filter,
            cancellationToken
            );

        return(localUsers
               .Cast <IUserData>()
               .ToList());
    }
Exemple #2
0
    public async Task <TUser> FindByUserNameAsync(string userName, CancellationToken cancellationToken = default)
    {
        var localUser = await _userRepository.FindByUserNameAsync(userName, cancellationToken);

        if (ExternalUserLookupServiceProvider == null)
        {
            return(localUser);
        }

        if (SkipExternalLookupIfLocalUserExists && localUser != null)
        {
            return(localUser);
        }

        IUserData externalUser;

        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));
                }

                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));
        }

        if (localUser is IUpdateUserData && ((IUpdateUserData)localUser).Update(externalUser))
        {
            await WithNewUowAsync(() => _userRepository.UpdateAsync(localUser, cancellationToken: cancellationToken));
        }
        else
        {
            return(localUser);
        }

        return(await _userRepository.FindAsync(externalUser.Id, cancellationToken : cancellationToken));
    }
Exemple #3
0
    public async Task <long> GetCountAsync(
        string filter = null,
        CancellationToken cancellationToken = default)
    {
        if (ExternalUserLookupServiceProvider != null)
        {
            return(await ExternalUserLookupServiceProvider
                   .GetCountAsync(
                       filter,
                       cancellationToken
                       ));
        }

        return(await _userRepository
               .GetCountAsync(
                   filter,
                   cancellationToken
                   ));
    }