public async Task Add(Rfa rfa)
        {
            _supplierManagementContext.Rfas.RemoveRange(_supplierManagementContext.Rfas.Where(x => x.UserId == rfa.UserId).ToList());

            await _supplierManagementContext.Rfas.AddAsync(rfa);

            await _supplierManagementContext.SaveChangesAsync();
        }
        public async Task <Unit> Handle(UpdateRfaCommand request, CancellationToken cancellationToken)
        {
            var id            = new UserId(request.User.Id);
            var userToUpdated = await _repositoryUser.GetById(id);

            if (userToUpdated == null)
            {
                throw new UserNotFoundForUpdateException();
            }

            var role = await _roleRepository.GetRole(request.User.Role.Name);

            if (role == null)
            {
                throw new RoleNotFoundForUpdateUserException();
            }

            var email      = new Email(request.Email);
            var existEmail = await _repositoryUser.CheckMailExist(id, email);

            if (existEmail)
            {
                throw new EmailAlreadyAffectedException();
            }

            userToUpdated.UpdateFirstName(request.User.FirstName);
            userToUpdated.UpdateLastName(request.User.LastName);
            userToUpdated.UpdateEmail(request.Email);
            userToUpdated.UpdateRole(role);

            await _repositoryUser.Update(userToUpdated);

            var rfa = await _repository.GetRfaByEmail(userToUpdated.Email);

            if (rfa == null)
            {
                // cas d'un changement de role mais avec un utilisateur qui existe déjà

                rfa = Rfa.Create(
                    userToUpdated.Id,
                    new Email(request.User.Email),
                    new PhoneNumber(request.PhoneNumber),
                    new Profession(request.Profession));

                await _repository.Add(rfa);
            }
            else
            {
                rfa = Rfa.Update(rfa, new Email(request.User.Email), new PhoneNumber(request.PhoneNumber), new Profession(request.Profession));

                await _repository.Update(rfa);
            }

            return(new Unit());
        }
        public async Task <Unit> Handle(AddRfaCommand request, CancellationToken cancellationToken)
        {
            var role = await _roleRepository.GetRole(request.User.Role.Name);

            if (role == null)
            {
                throw new RoleNotFoundForAddUserException();
            }


            var email      = new Email(request.User.Email);
            var id         = new UserId(Guid.NewGuid());
            var existEmail = await _repositoryUser.CheckMailExist(id, email);

            if (existEmail)
            {
                throw new EmailAlreadyAffectedException();
            }

            var user = User.Create(
                id,
                new FirstName(request.User.FirstName),
                new LastName(request.User.LastName),
                email,
                role
                );

            await _repositoryUser.AddAsync(user);

            var rfa = Rfa.Create(
                user.Id,
                new Email(request.User.Email),
                new PhoneNumber(request.PhoneNumber),
                new Profession(request.Profession));

            await _repository.Add(rfa);

            return(new Unit());
        }
 public async Task Update(Rfa rfa)
 {
     _supplierManagementContext.Rfas.Update(rfa);
     await _supplierManagementContext.SaveChangesAsync();
 }
 public async Task Delete(Rfa rfa)
 {
     _supplierManagementContext.Rfas.Remove(rfa);
     await _supplierManagementContext.SaveChangesAsync();
 }