public async Task <DefaultEntityCommandResponse <Common.Domain.Entities.Player> > Handle(AddPlayerCommand command)
        {
            this._unitOfWork.Begin();
            try
            {
                this._validationResult = await this._validator.ValidateAsync(command);

                if (this._validationResult.IsValid)
                {
                    command.Registration = RegistrationNumberHelper.Format(command.Registration, command.Gender);
                }

                if (this._validationResult.IsValid && !command.AutoGenerateRegistration)
                {
                    var existing = await this._playerRepository.GetByRegistration(command.Registration);

                    if (existing != null)
                    {
                        this._validationResult.Errors.Add(new ValidationFailure("Registration", $"Registration is already in use by player {existing.DisplayName}."));
                    }
                }

                if (this._validationResult.IsValid)
                {
                    var player = new Common.Domain.Entities.Player
                    {
                        Forename       = command.FirstName,
                        Surname        = command.LastName,
                        GenderID       = command.Gender,
                        RegistrationID = command.Registration
                    };
                    player.SetAuditFields(this._applicationUser.ID);
                    await this._playerRepository.Save(player);

                    await this._playerRepository.Flush();

                    if (command.AutoGenerateRegistration)
                    {
                        player.RegistrationID = $"TEMP{player.ID}";
                        await this._playerRepository.Save(player);
                    }

                    this._unitOfWork.SoftCommit();

                    return(DefaultEntityCommandResponse <Common.Domain.Entities.Player> .Create(this._validationResult, player));
                }
                else
                {
                    this._unitOfWork.Rollback();
                    return(DefaultEntityCommandResponse <Common.Domain.Entities.Player> .Create(this._validationResult));
                }
            }
            catch (Exception exception)
            {
                this._unitOfWork.Rollback();
                this._logger.LogError(exception, "Exception in Command Handler");
                throw;
            }
        }
        public async Task <DefaultCommandResponse> Handle(UpdatePlayerCommand command)
        {
            this._unitOfWork.Begin();
            try
            {
                var player = await this._playerRepository.GetForUpdate(command.ID);

                this._validationResult = await this._validator.ValidateAsync(command);

                if (this._validationResult.IsValid)
                {
                    command.Registration = RegistrationNumberHelper.Format(command.Registration, command.Gender);

                    var existing = await this._playerRepository.GetByRegistration(command.Registration);

                    if (existing != null && existing.ID != player.ID)
                    {
                        this._validationResult.Errors.Add(new ValidationFailure("Registration", $"Registration is already in use by player {existing.DisplayName}."));
                    }
                }

                if (this._validationResult.IsValid)
                {
                    player.Forename       = command.FirstName;
                    player.Surname        = command.LastName;
                    player.GenderID       = command.Gender;
                    player.RegistrationID = command.Registration;
                    player.SetAuditFields(this._applicationUser.ID);
                    await this._playerRepository.Save(player);

                    this._unitOfWork.SoftCommit();

                    return(DefaultCommandResponse.Create(this._validationResult));
                }
                else
                {
                    this._unitOfWork.Rollback();
                    return(DefaultCommandResponse.Create(this._validationResult));
                }
            }
            catch (Exception exception)
            {
                this._unitOfWork.Rollback();
                this._logger.LogError(exception, "Exception in Command Handler");
                throw;
            }
        }