AccountService.cs

using System.Collections.Generic;
using Microsoft.AspNetCore.Identity;
using System.Threading.Tasks;
using System.Linq;
using AutoMapper;
using Google.Apis.Auth;
using HwProj.AuthService.API.Extensions;
using HwProj.Models.Roles;
using HwProj.AuthService.API.Events;
using HwProj.EventBus.Client.Interfaces;
using HwProj.Models.AuthService.DTO;
using HwProj.Models.AuthService.ViewModels;
using HwProj.Models.Result;

namespace HwProj.AuthService.API.Services
{
    public class AccountService : IAccountService
    {
        private readonly IUserManager _userManager;
        private readonly SignInManager<UserViewModel> _signInManager;
        private readonly IAuthTokenService _tokenService;
        private readonly IEventBus _eventBus;
        private readonly IMapper _mapper;

        public AccountService(IUserManager userManager,
            SignInManager<UserViewModel> signInManager,
            IAuthTokenService authTokenService,
            IEventBus eventBus,
            IMapper mapper)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _tokenService = authTokenService;
            _eventBus = eventBus;
            _mapper = mapper;
        }

        public async Task<AccountDataDto> GetAccountDataAsync(string userId)
        {
            var user = await _userManager.FindByIdAsync(userId).ConfigureAwait(false);
            if (user == null)
            {
                return null;
            }

            var userRoles = await _userManager.GetRolesAsync(user).ConfigureAwait(false);
            var userRole = userRoles.FirstOrDefault() ?? Roles.StudentRole;
            return new AccountDataDto(user.Name, user.Surname, user.Email, userRole, user.IsExternalAuth, user.MiddleName);
        }

        public async Task<Result> EditAccountAsync(string id, EditDataDTO model)
        {
            var user = await _userManager.FindByIdAsync(id).ConfigureAwait(false);
            if (user == null)
            {
                return Result.Failed("Пользователь не найден");
            }

            if (!user.IsExternalAuth && !await _userManager.CheckPasswordAsync(user, model.CurrentPassword))
            {
                return Result.Failed("Неправильный логин или пароль");
            }

            var result = user.IsExternalAuth
                ? await ChangeUserNameTask(user, model)
                : await ChangeUserNameTask(user, model).Then(() => ChangePasswordAsync(user, model));

            if (result.Succeeded)
            {
                _eventBus.Publish(new EditProfileEvent(id));
                return Result.Success();
            }

            return Result.Failed();
        }

        public async Task<Result<TokenCredentials>> LoginUserAsync(LoginViewModel model)
        {
            if (await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false)
                    is var user && user == null)
            {
                return Result<TokenCredentials>.Failed("Пользователь не найден");
            }

            if (!await _userManager.IsEmailConfirmedAsync(user).ConfigureAwait(false))
            {
                return Result<TokenCredentials>.Failed("Электронная почта не подтверждена");
            }

            var result = await _signInManager.PasswordSignInAsync(
                user,
                model.Password,
                model.RememberMe,
                false).ConfigureAwait(false);

            if (!result.Succeeded)
            {
                return Result<TokenCredentials>.Failed(result.TryGetIdentityError());
            }

            var token = await _tokenService.GetTokenAsync(user).ConfigureAwait(false);
            return Result<TokenCredentials>.Success(token);
        }
        
        public async Task<Result<TokenCredentials>> LoginUserByGoogleAsync(GoogleJsonWebSignature.Payload payload)
        {
            if (await _userManager.FindByEmailAsync(payload.Email).ConfigureAwait(false)
                is var user && user == null)
            {
                var userModel = new RegisterDataDTO()
                {
                    Email = payload.Email,
                    Name = payload.GivenName,
                    Surname = payload.FamilyName,
                    IsExternalAuth = true
                };

                return await RegisterUserAsync(userModel);
            }
            
            return await GetToken(user);
        }

        public async Task<Result<TokenCredentials>> RegisterUserAsync(RegisterDataDTO model)
        {
            if (await _userManager.FindByEmailAsync(model.Email) != null)
            {
                return Result<TokenCredentials>.Failed("Пользователь уже зарегистрирован");
            }
            
            if(!model.IsExternalAuth && model.Password.Length < 6)
            {
                return Result<TokenCredentials>.Failed("Пароль должен содержать не менее 6 символов");
            }

            var user = _mapper.Map<UserViewModel>(model);
            user.UserName = user.Email.Split('@')[0];

            var createUserTask = model.IsExternalAuth
                ? _userManager.CreateAsync(user)
                : _userManager.CreateAsync(user, model.Password);

            if (!model.IsExternalAuth && createUserTask.Result.Succeeded && !await _userManager.CheckPasswordAsync(user, model.PasswordConfirm))
            {
                return Result<TokenCredentials>.Failed("Пароли не совпадают");
            }
            
            var result = await createUserTask
                .Then(() => _userManager.AddToRoleAsync(user, Roles.StudentRole))
                .Then(() =>
                {
                    user.EmailConfirmed = true;
                    return _userManager.UpdateAsync(user);
                });

            if (result.Succeeded)
            {
                var newUser = await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false);
                var registerEvent = new StudentRegisterEvent(newUser.Id, newUser.Email, newUser.Name,
                    newUser.Surname, newUser.MiddleName);
                _eventBus.Publish(registerEvent);
                
                if (!model.IsExternalAuth)
                {
                    await SignIn(user, model.Password);
                }

                return await GetToken(user);
            }

            return Result<TokenCredentials>.Failed(result.Errors.Select(errors => errors.Description).ToArray());
        }

        public async Task<Result> InviteNewLecturer(string emailOfInvitedUser)
        {
            var invitedUser = await _userManager.FindByEmailAsync(emailOfInvitedUser).ConfigureAwait(false);

            if (invitedUser == null)
            {
                return Result.Failed("Пользователь не найден");
            }

            var result = await _userManager.AddToRoleAsync(invitedUser, Roles.LecturerRole)
                .Then(() => _userManager.RemoveFromRoleAsync(invitedUser, Roles.StudentRole)).ConfigureAwait(false);

            if (result.Succeeded)
            {
                var inviteEvent = new InviteLecturerEvent(invitedUser.Id);
                _eventBus.Publish(inviteEvent);
                return Result.Success();
            }

            return Result.Failed();
        }

        public async Task<AccountDataDto[]> GetAllStudents()
        {
            var result = await _userManager.GetUsersInRoleAsync(Roles.StudentRole);
            return result
                .Select(u => new AccountDataDto(u.Name, u.Surname, u.Email, Roles.StudentRole, u.IsExternalAuth, u.MiddleName))
                .ToArray();;
        }

        private Task<IdentityResult> ChangeUserNameTask(UserViewModel userViewModel, EditDataDTO model)
        {
            if (!string.IsNullOrWhiteSpace(model.Name))
            {
                userViewModel.Name = model.Name;
            }
            if (!string.IsNullOrWhiteSpace(model.Name))
            {
                userViewModel.Surname = model.Surname;
            }
            if (!string.IsNullOrWhiteSpace(model.Name))
            {
                userViewModel.MiddleName = model.MiddleName;
            }

            return _userManager.UpdateAsync(userViewModel);
        }

        private Task<IdentityResult> ChangePasswordAsync(UserViewModel userViewModel, EditDataDTO model)
        {
            return !string.IsNullOrWhiteSpace(model.NewPassword)
                ? _userManager.ChangePasswordAsync(userViewModel, model.CurrentPassword, model.NewPassword)
                : Task.FromResult(IdentityResult.Success);
        }

        private async Task SignIn(UserViewModel userViewModel, string password)
        {
            await _signInManager.PasswordSignInAsync(userViewModel, password, false, false)
                .ConfigureAwait(false);
        }

        private async Task<Result<TokenCredentials>> GetToken(UserViewModel userViewModel)
        {
            return Result<TokenCredentials>.Success(await _tokenService.GetTokenAsync(userViewModel).ConfigureAwait(false));
        }
    }
}