コード例 #1
0
        private void ValidateHasCompleteDocuments(Guid withdrawalId, Payment.Data.Player player, Guid brandId)
        {
            if (!_configuration.HasCompleteDocuments)
            {
                return;
            }

            var ruleResult = true;

            //Kristian: I leave it like this because the validation doesn't have a return code or value
            //but it directly throws an exception if one of the needed documents is not present for that player.
            try
            {
                _identityValidator.Validate(player.Id, Common.Data.Player.TransactionType.Withdraw);
            }
            catch
            {
                ruleResult = false;
            }

            var metadataForRule = GenerateFullRuleDescriptionAndValue(
                VerificationStep.HasDocuments,
                ComparisonEnum.Is,
                _configuration.HasCompleteDocuments.ToString(),
                ruleResult.ToString());

            OnRuleFinish(ruleResult, withdrawalId, VerificationStep.HasDocuments, metadataForRule);
        }
コード例 #2
0
        //[Permission(Permissions.Create, Module = Modules.OfflineDepositRequests)]
        public async Task <OfflineDeposit> Submit(OfflineDepositRequest request)
        {
            var validationResult = _offlineDepositQueries.GetValidationResult(request);

            if (validationResult.IsValid == false)
            {
                throw new RegoException(string.Join("/n", validationResult.Errors.Select(failure => failure.ErrorMessage)));
            }

            var player = _repository.Players
                         .Include(x => x.Brand)
                         .Single(p => p.Id == request.PlayerId);

            var bankAccount = _repository.BankAccounts
                              .Include(x => x.Bank)
                              .Single(x => x.Id == request.BankAccountId);

            _validator.Validate(request.PlayerId, bankAccount.CurrencyCode, request.Amount);
            _identityValidator.Validate(request.PlayerId, TransactionType.Deposit);

            var deposit = new Entities.OfflineDeposit(request, bankAccount, player, _actorInfoProvider.Actor.UserName);

            using (var scope = CustomTransactionScope.GetTransactionScopeAsync())
            {
                var depositEvent = deposit.Submit();
                _repository.OfflineDeposits.Add(deposit.Data);

                if (request.BonusId.HasValue || string.IsNullOrWhiteSpace(request.BonusCode) == false)
                {
                    var bonusRedemptionId = await _bonusApiProxy.ApplyForBonusAsync(new DepositBonusApplication
                    {
                        PlayerId  = player.Id,
                        BonusId   = request.BonusId,
                        BonusCode = request.BonusCode,
                        Amount    = request.Amount,
                        DepositId = deposit.Data.Id
                    });

                    deposit.SetBonusRedemption(bonusRedemptionId);
                }

                _repository.SaveChanges();
                _eventBus.Publish(depositEvent);
                scope.Complete();
            }

            var messageModel = new OfflineDepositRequestedModel
            {
                BankName          = bankAccount.Bank.BankName,
                BankAccountName   = bankAccount.AccountName,
                BankAccountNumber = bankAccount.AccountNumber
            };

            _messageTemplateService.TrySendPlayerMessage(
                player.Id,
                MessageType.OfflineDepositRequested,
                MessageDeliveryMethod.Email,
                messageModel);

            _messageTemplateService.TrySendPlayerMessage(
                player.Id,
                MessageType.OfflineDepositRequested,
                MessageDeliveryMethod.Sms,
                messageModel);

            var data = Mapper.Map <OfflineDeposit>(deposit.Data);

            return(data);
        }