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;
            }
        }
Ejemplo n.º 2
0
        public async Task <ApiResponse> Add([FromBody] AddPlayerCommand command)
        {
            DefaultEntityCommandResponse <Com.BinaryBracket.BowlsResults.Common.Domain.Entities.Player> response = await this._addPlayerCommandHandler.Handle(command);

            var apiResponse = this.BuildApiResponse(response);

            apiResponse.Result = response.Entity.AssembleDto();
            return(apiResponse);
        }