Exemple #1
0
        public async Task <LockableResult <AccountDetailsOutDto> > Create(AccountNewDto accountIn)
        {
            if (accountIn.AuthorizedLimit != null && accountIn.AuthorizedLimit.Currency != accountIn.InitialBalance.Currency)
            {
                return(new BadRequestLockableResult <AccountDetailsOutDto>(BadRequestOutDto.WrongCurrencyType));
            }
            var rand                = new Random();
            var dateTimeNow         = DateTimeOffset.UtcNow;
            var accountDetailEntity = new AccountDetailEntity()
            {
                ResourceId      = Guid.NewGuid(),
                Name            = accountIn.Name,
                Product         = accountIn.Product,
                CashAccountType = accountIn.CashAccountType,
                Status          = accountIn.Status,
                Usage           = accountIn.Usage,
                Lock            = null,
                Pan             = string.Join("", "000123456789".Select(c => rand.Next(0, 10))),
                Msisdn          = accountIn.Msisdn,
                Currency        = accountIn.InitialBalance.Currency,
                RoutingNumbers  = new AccountReferenceEntity.RoutingNumbersEntity()
                {
                    Ach = AabRoutingNumbers.GetRandomRoutingNumber()
                },
                Balances = new BalanceEntity[]
                {
                    new BalanceEntity()
                    {
                        BalanceType              = BalanceTypeEnum.closingBooked,
                        BalanceAmount            = accountIn.InitialBalance.ToEntity(),
                        CreditLimitIncluded      = false,
                        LastChangeDateTime       = dateTimeNow,
                        LastCommittedTransaction = null
                    },
                },
                AuthorizedLimit = accountIn.AuthorizedLimit?.ToEntity()
            };

            if (accountIn.AuthorizedLimit != null)
            {
                accountDetailEntity.Balances = accountDetailEntity.Balances.Concat(new BalanceEntity[]
                {
                    new BalanceEntity()
                    {
                        BalanceType              = BalanceTypeEnum.authorised,
                        BalanceAmount            = accountIn.InitialBalance.ToEntity().Add(accountIn.AuthorizedLimit.ToEntity()),
                        CreditLimitIncluded      = true,
                        LastChangeDateTime       = dateTimeNow,
                        LastCommittedTransaction = null
                    },
                });
            }

            accountDetailEntity.LastModifiedDate = dateTimeNow;
            accountDetailEntity.CreatedDate      = dateTimeNow;

            await _accounts.InsertOneAsync(accountDetailEntity);

            return(new SuccessfulLockableResult <AccountDetailsOutDto>(AccountDetailsOutDto.EntityToOutDto(accountDetailEntity)));
        }
        public async Task <IActionResult> AddNewAccount(AccountNewDto account)
        {
            var createdAccountResult = await _accountService.Create(account);

            switch (createdAccountResult)
            {
            case BadRequestLockableResult <AccountDetailsOutDto> badRequestLockableResult:
                return(BadRequest(badRequestLockableResult.Problem));

            case FailedLockableResult <AccountDetailsOutDto> failedLockableResult:
                return(StatusCode(StatusCodes.Status500InternalServerError, failedLockableResult.Error));

            case SuccessfulLockableResult <AccountDetailsOutDto> successfulLockableResult:
                return(Ok(successfulLockableResult.Value));

            default:
                throw new ArgumentOutOfRangeException(nameof(createdAccountResult));
            }
        }