GetTransactionCategoryResponses(string userId, bool detailed = false) { //Check cache var cachedTransactions = await _userDataCachingService.RetrieveTransactions(userId); if (!cachedTransactions.Success) { return(ServiceObjectResult <TransactionCategoryResponse> .Failed(null, cachedTransactions.Errors)); } if (cachedTransactions.Result != null && cachedTransactions.Result.Any()) { return(ServiceObjectResult <TransactionCategoryResponse> .Succeeded(CreateCategoryResponse(cachedTransactions.Result, detailed))); } //Obtain all valid access contexts var accessContextResult = await ObtainValidAccountContexts(userId); if (!accessContextResult.Success) { return(ServiceObjectResult <TransactionCategoryResponse> .Failed(null, accessContextResult.Errors)); } var transactionsResult = await ObtainTransactionsForAccountContexts(accessContextResult.Result); if (!transactionsResult.Success) { return(ServiceObjectResult <TransactionCategoryResponse> .Failed(null, transactionsResult.Errors)); } await _userDataCachingService.CacheTransactions(userId, transactionsResult.Result, TimeSpan.FromMinutes(10)); return(ServiceObjectResult <TransactionCategoryResponse> .Succeeded(CreateCategoryResponse(transactionsResult.Result, detailed))); }
private IActionResult GenerateResultFromServiceResult <TResultType>( ServiceObjectResult <TResultType> serviceObjectResult) { if (serviceObjectResult.Success) { return(Ok(serviceObjectResult.Result)); } if (serviceObjectResult.Errors.Contains(ErrorCodeStrings.InternalError)) { return(StatusCode(500, serviceObjectResult.Errors)); } if (serviceObjectResult.Errors.Contains(ErrorCodeStrings.BadRequestError)) { return(BadRequest(serviceObjectResult.Errors)); } if (serviceObjectResult.Errors.Contains(ErrorCodeStrings.NotFoundError)) { return(NotFound(serviceObjectResult.Errors)); } if (serviceObjectResult.Errors.Any()) { return(StatusCode(500, serviceObjectResult.Errors)); } return(StatusCode(500, "The request could not be processed due to an unknown reason.")); }
private async Task <ServiceObjectResult <ICollection <AccountAccessContext> > > ObtainValidAccountContexts(string userId) { //Refresh access on all users accounts where required var accessRefreshResult = await _authorizationService.AttemptRefreshAccountContexts(userId); if (!accessRefreshResult.Success) { return(ServiceObjectResult <ICollection <AccountAccessContext> > .Failed(null, accessRefreshResult.Errors)); } //ObtainAccessContexts var accessContextResult = await _accessCachingService.RetrieveAccessContexts(userId, new List <Scope> { Scope.transactions, Scope.accounts }); if (!accessContextResult.Success) { return(ServiceObjectResult <ICollection <AccountAccessContext> > .Failed(null, accessContextResult.Errors)); } if (accessContextResult.Result == null) { return(ServiceObjectResult <ICollection <AccountAccessContext> > .Failed(null, new List <string> { ErrorMessages.UserNotFound })); } return(ServiceObjectResult <ICollection <AccountAccessContext> > .Succeeded(accessContextResult.Result)); }
public async Task <ServiceObjectResult <ICollection <Transaction> > > GetAllTransactions(string userId) { //Check cache var cachedTransactions = await _userDataCachingService.RetrieveTransactions(userId); if (!cachedTransactions.Success) { return(ServiceObjectResult <ICollection <Transaction> > .Failed(null, cachedTransactions.Errors)); } if (cachedTransactions.Result != null && cachedTransactions.Result.Any()) { return(ServiceObjectResult <ICollection <Transaction> > .Succeeded(cachedTransactions.Result)); } //Obtain all valid access contexts var accessContextResult = await ObtainValidAccountContexts(userId); if (!accessContextResult.Success) { return(ServiceObjectResult <ICollection <Transaction> > .Failed(null, accessContextResult.Errors)); } var transactionsResult = await ObtainTransactionsForAccountContexts(accessContextResult.Result); if (!transactionsResult.Success) { return(ServiceObjectResult <ICollection <Transaction> > .Failed(null, transactionsResult.Errors)); } await _userDataCachingService.CacheTransactions(userId, transactionsResult.Result, TimeSpan.FromMinutes(10)); return(ServiceObjectResult <ICollection <Transaction> > .Succeeded(transactionsResult.Result)); }
private async Task <ServiceObjectResult <ICollection <Transaction> > > ObtainTransactionsForAccountContexts( ICollection <AccountAccessContext> accessContexts) { var transactions = new List <Transaction>(); foreach (var accessContext in accessContexts) { var accountLookupResult = await _accountService.GetAccountsInContext(accessContext); if (!accountLookupResult.Success) { return(ServiceObjectResult <ICollection <Transaction> > .Failed(null, accountLookupResult.Errors)); } foreach (var accountId in accountLookupResult.Result.Select(x => x.AccountId).Distinct()) { var transactionLookupResult = await _requestExecutor.GetTransactions(accessContext.AccessToken, accountId); if (!transactionLookupResult.Success) { return(ServiceObjectResult <ICollection <Transaction> > .Failed(null, transactionLookupResult.Errors)); } transactions.AddRange(transactionLookupResult.Result.Results); } } return(ServiceObjectResult <ICollection <Transaction> > .Succeeded(transactions)); }
public async void RefreshAccountTokens_Should_Remove_Access_If_RefreshToken_Empty_When_Expired() { _mockAccessContextCachingService.Setup(x => x.RetrieveAccessContexts(It.IsAny <string>(), null)) .ReturnsAsync(ServiceObjectResult <ICollection <AccountAccessContext> > .Succeeded(new List <AccountAccessContext> { new AccountAccessContext { AccessTokenExpiry = DateTime.UtcNow } })); _mockRequestExecutor.Setup(x => x.RefreshAccountAccess(It.IsAny <AccountAccessContext>())) .ReturnsAsync(ServiceObjectResult <AuthResponse> .Succeeded(new AuthResponse { ExpiresIn = 9999, AccessToken = "string", RefreshToken = "string" })); var result = await _authorizationService.AttemptRefreshAccountContexts("myuser"); Assert.True(result.Success); _mockRequestExecutor.Verify(x => x.RefreshAccountAccess(It.IsAny <AccountAccessContext>()), Times.Never()); _mockAccessContextCachingService.Verify(x => x.RemoveAccessContext(It.IsAny <AccountAccessContext>()), Times.Once); }
public async void GetAllTransactions_Should_Retrieve_Accounts_For_Each_Context() { var userId = Guid.NewGuid().ToString(); var accessCode1 = Guid.NewGuid().ToString(); var accessCode2 = Guid.NewGuid().ToString(); SetupEmptyCacheCall(userId); _mockAuthorizationService.Setup(x => x.AttemptRefreshAccountContexts(userId)) .ReturnsAsync(ServiceResult.Succeeded); SetupAccessContextRetrieval(userId, new List <AccountAccessContext> { new AccountAccessContext { AccessToken = accessCode1 }, new AccountAccessContext { AccessToken = accessCode2 } }); _mockAccountService.Setup(x => x.GetAccountsInContext(It.IsAny <AccountAccessContext>())) .ReturnsAsync(ServiceObjectResult <ICollection <Account> > .Succeeded(new List <Account>())); var result = await _transactionService.GetTransactionCategoryResponses(userId); _mockAccountService.Verify(x => x.GetAccountsInContext(It.Is <AccountAccessContext>( context => context.AccessToken == accessCode1)), Times.Once); _mockAccountService.Verify(x => x.GetAccountsInContext(It.Is <AccountAccessContext>( context => context.AccessToken == accessCode2)), Times.Once); }
public async Task <ServiceObjectResult <ResponseEnvelope <PaymentResponse> > > ProcessPaymentRequest(PaymentRequest request) { var responseEnvelope = new ResponseEnvelope <PaymentResponse>(); var validationResult = _requestValidator.ValidateRequest(request); if (!validationResult.Success) { responseEnvelope.ValidationErrors = validationResult.Result; return(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Failed( responseEnvelope, validationResult.Errors)); } var paymentResult = await _paymentExecutionService.ExecutePayment(request); if (!paymentResult.Success) { return(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Failed(null, new List <string> { ErrorCodeStrings.InternalError })); } await _repository.PutItemAsync(paymentResult.Result); responseEnvelope.ResponseValue = new PaymentResponse { PaymentIdentifier = paymentResult.Result.PaymentIdentifier, Status = paymentResult.Result.Status.ToString() }; return(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Succeeded(responseEnvelope)); }
public async Task <ServiceObjectResult <Panel> > CreatePanelAsync(Panel model) { var validationResult = await _validationService.ValidateAsync <CreatePanelValidator, Panel>(model); if (!validationResult.IsValid) { return(ServiceObjectResult <Panel> .Error(validationResult)); } if (model.ProjectId.HasValue) { var existingProject = await _projectRepository.GetByIdAsync(model.ProjectId.Value); model.Project = existingProject; } if (model is MemePanel panel) { var memeImage = await _memeImageRepository.GetRandomMemes(1); panel.StaticMemeUrl = memeImage.Select(i => i.ImageUrl).FirstOrDefault(); } var r = await _panelRepository.AddAsync(model); await _panelRepository.SaveAsync(); if (model.Project != null) { BackgroundJob.Enqueue <IProjectService>(s => s.UpdateCiDataForProjectAsync(model.Project.Id)); } return(ServiceObjectResult <Panel> .Ok(r)); }
private ServiceObjectResult <TReturnType> GenerateResponseForType <TReturnType>(string userId) where TReturnType : class { switch (userId) { case TestConstants.ValidUser: return(ServiceObjectResult <TReturnType> .Succeeded(null)); case TestConstants.ErrorUser: return(ServiceObjectResult <TReturnType> .Failed(null, new List <string> { ErrorCodeStrings.InternalError })); case TestConstants.BadRequestUser: return(ServiceObjectResult <TReturnType> .Failed(null, new List <string> { ErrorCodeStrings.BadRequestError })); case TestConstants.NotFoundUser: return(ServiceObjectResult <TReturnType> .Failed(null, new List <string> { ErrorCodeStrings.NotFoundError })); default: throw new NotImplementedException(); } }
public async Task <ServiceObjectResult <Panel> > UpdatePanelPosition(int panelId, PanelPosition position) { var validationResult = await _validationService.ValidateAsync <PanelPositionValidator, PanelPosition>(position); if (!validationResult.IsValid) { return(ServiceObjectResult <Panel> .Error(validationResult)); } var entity = await GetPanelByIdAsync(panelId); if (entity == null) { return(null); } //TODO: change when automaper entity.Position.Column = position.Column; entity.Position.Row = position.Row; entity.Position.Width = position.Width; entity.Position.Height = position.Height; var r = await _panelRepository.UpdateAsync(entity, panelId); await _panelRepository.SaveAsync(); return(ServiceObjectResult <Panel> .Ok(r)); }
public async Task <ServiceObjectResult <Panel> > UpdatePanelAsync(Panel updatedPanel) { var validationResult = await _validationService.ValidateAsync <UpdatePanelValidator, Panel>(updatedPanel); if (!validationResult.IsValid) { return(ServiceObjectResult <Panel> .Error(validationResult)); } var model = await GetPanelByIdAsync(updatedPanel.Id); if (model == null) { return(null); } if (updatedPanel.Discriminator != model.Discriminator) { return(null); } if (updatedPanel.ProjectId.HasValue) { var project = await _projectRepository.GetByIdAsync(updatedPanel.ProjectId.Value); model.Project = project; } var r = await _panelRepository.UpdateAsync(updatedPanel, model.Id); await _panelRepository.SaveAsync(); return(ServiceObjectResult <Panel> .Ok(r)); }
public Task <ServiceObjectResult <ResponseEnvelope <PaymentResponse> > > ProcessPaymentRequest(PaymentRequest request) { switch (request.CardNumber) { case TestConstants.ErrorCardNumber: return(Task.FromResult(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Failed(null, new List <string> { ErrorCodeStrings.InternalError }))); case TestConstants.BadRequestCardNumber: var validationErrors = new List <ValidationFieldError> { new ValidationFieldError(nameof(request.CardNumber), ErrorMessages.Validation.FieldInvalidContent) }; return(Task.FromResult(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Failed( new ResponseEnvelope <PaymentResponse> { ValidationErrors = validationErrors }, new List <string> { ErrorCodeStrings.BadRequestError }))); case TestConstants.SuccessCardNumber: return(Task.FromResult(ServiceObjectResult <ResponseEnvelope <PaymentResponse> > .Succeeded( new ResponseEnvelope <PaymentResponse> { ResponseValue = new PaymentResponse() }))); default: throw new NotImplementedException(); } }
public async Task <ServiceObjectResult <Project> > UpdateProjectAsync(Project updatedProject) { var validationResult = await _validationService.ValidateAsync <UpdateProjectValidator, Project>(updatedProject); if (!validationResult.IsValid) { return(ServiceObjectResult <Project> .Error(validationResult)); } var project = await GetProjectByIdAsync(updatedProject.Id); //TODO: change when automapper project.ProjectTitle = updatedProject.ProjectTitle; project.ApiAuthenticationToken = updatedProject.ApiAuthenticationToken; project.ApiHostUrl = updatedProject.ApiHostUrl; project.ApiProjectId = updatedProject.ApiProjectId; project.DataProviderName = updatedProject.DataProviderName; project.CiDataUpdateCronExpression = updatedProject.CiDataUpdateCronExpression; _cronJobsManager.UpdateCiDataForProject(updatedProject); var r = await _projectRepository.UpdateAsync(project, updatedProject.Id); await _projectRepository.SaveAsync(); return(ServiceObjectResult <Project> .Ok(r)); }
public async Task <ServiceObjectResult <PaymentResult> > ExecutePayment(PaymentRequest paymentRequest) { var sendPaymentResponse = await _bankRequestClient.SendPayment(paymentRequest); if (!sendPaymentResponse.Success || sendPaymentResponse.Result?.PaymentIdentifier == null) { return(ServiceObjectResult <PaymentResult> .Failed(null, sendPaymentResponse.Errors ?? new List <string> { ErrorCodeStrings.InternalError })); } if (!Enum.TryParse <PaymentStatus>(sendPaymentResponse.Result.Status, out var paymentStatus)) { return(ServiceObjectResult <PaymentResult> .Failed(null, ErrorMessages.UnableToProcessPayment)); } var paymentResult = new PaymentResult { PaymentIdentifier = sendPaymentResponse.Result.PaymentIdentifier, CardNumber = paymentRequest.CardNumber, Amount = paymentRequest.Amount, Status = paymentStatus, Timestamp = DateTime.UtcNow }; return(ServiceObjectResult <PaymentResult> .Succeeded(paymentResult)); }
public async Task <ServiceObjectResult <TDataType> > GetItem(string partitionKey) { var result = await _dynamoDbContext.LoadAsync <TDataType>(partitionKey); return(result != null ? ServiceObjectResult <TDataType> .Succeeded(result) : ServiceObjectResult <TDataType> .Failed(null, ErrorCodes.Status.NotFound)); }
public async Task <ServiceObjectResult <DeliveryRecord> > Update(DeliveryRecord delivery) { var result = await _repository.UpdateItem(delivery); return(!result.Success ? ServiceObjectResult <DeliveryRecord> .Failed(null, result.Errors) : ServiceObjectResult <DeliveryRecord> .Succeeded(delivery)); }
public async Task <ServiceObjectResult <DeliveryRecord> > Select(string deliveryId) { var result = await _repository.GetItem(deliveryId); return(!result.Success ? ServiceObjectResult <DeliveryRecord> .Failed(null, result.Errors) : ServiceObjectResult <DeliveryRecord> .Succeeded(result.Result)); }
public async Task <ServiceObjectResult <ICollection <AccountAccessContext> > > RetrieveAccessContexts(string userId, ICollection <Scope> requiredScopes = null) { var accessContexts = await _cache.Get <List <AccountAccessContext> >(userId); return(requiredScopes == null ? ServiceObjectResult <ICollection <AccountAccessContext> > .Succeeded(accessContexts) : ServiceObjectResult <ICollection <AccountAccessContext> > .Succeeded( accessContexts.Where(x => x.Scopes.Distinct().Intersect(requiredScopes.Distinct()).Count() == requiredScopes.Distinct().Count()).ToList())); }
public async void GetTransactionCategoryResponses_Should_Retrieve_Transactions_For_Each_Account() { var userId = Guid.NewGuid().ToString(); var accessCode1 = Guid.NewGuid().ToString(); var accessCode2 = Guid.NewGuid().ToString(); var accountCode1 = Guid.NewGuid().ToString(); var accountCode2 = Guid.NewGuid().ToString(); var accountCode3 = Guid.NewGuid().ToString(); var accountCode4 = Guid.NewGuid().ToString(); SetupEmptyCacheCall(userId); _mockAuthorizationService.Setup(x => x.AttemptRefreshAccountContexts(userId)) .ReturnsAsync(ServiceResult.Succeeded); SetupAccessContextRetrieval(userId, new List <AccountAccessContext> { new AccountAccessContext { AccessToken = accessCode1 }, new AccountAccessContext { AccessToken = accessCode2 } }); _mockAccountService.Setup(x => x.GetAccountsInContext(It.Is <AccountAccessContext>(context => context.AccessToken == accessCode1))) .ReturnsAsync(ServiceObjectResult <ICollection <Account> > .Succeeded(new List <Account> { new Account { AccountId = accountCode1 }, new Account { AccountId = accountCode2 } })); _mockAccountService.Setup(x => x.GetAccountsInContext(It.Is <AccountAccessContext>(context => context.AccessToken == accessCode2))) .ReturnsAsync(ServiceObjectResult <ICollection <Account> > .Succeeded(new List <Account> { new Account { AccountId = accountCode3 }, new Account { AccountId = accountCode4 } })); _mockTrueLayerDataRequestExecutor.Setup(x => x.GetTransactions(It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync( ServiceObjectResult <TrueLayerListResponse <Transaction> > .Succeeded( new TrueLayerListResponse <Transaction> { Results = new List <Transaction>() })); var result = await _transactionService.GetTransactionCategoryResponses(userId); _mockTrueLayerDataRequestExecutor.Verify(x => x.GetTransactions(accessCode1, accountCode1), Times.Once); _mockTrueLayerDataRequestExecutor.Verify(x => x.GetTransactions(accessCode1, accountCode2), Times.Once); _mockTrueLayerDataRequestExecutor.Verify(x => x.GetTransactions(accessCode2, accountCode3), Times.Once); _mockTrueLayerDataRequestExecutor.Verify(x => x.GetTransactions(accessCode2, accountCode4), Times.Once); }
public async void ExecutePayment_Should_Return_Failed_If_Client_Result_Has_No_Identifier() { _mockBankRequestClient.Setup(x => x.SendPayment(It.IsAny <PaymentRequest>())) .ReturnsAsync(ServiceObjectResult <BankPaymentResponse> .Succeeded(new BankPaymentResponse())); var result = await _paymentExecutionService.ExecutePayment(new PaymentRequest()); Assert.False(result.Success); }
public async Task <ServiceObjectResult <DeliveryRecord> > Create(DeliveryRecord delivery) { delivery.DeliveryId = Guid.NewGuid().ToString(); var saveResult = await _repository.PutItem(delivery); return(saveResult.Success ? ServiceObjectResult <DeliveryRecord> .Succeeded(delivery) : ServiceObjectResult <DeliveryRecord> .Failed(null, saveResult.Errors)); }
private void SetupRefreshCodeCall() { _mockRequestExecutor.Setup(x => x.RefreshAccountAccess(It.IsAny <AccountAccessContext>())) .ReturnsAsync(ServiceObjectResult <AuthResponse> .Succeeded(new AuthResponse { ExpiresIn = 9999, AccessToken = "string", RefreshToken = "string" })); }
private void SetupPaymentExecutionService(string cardNumber, bool success, string resultReference = null) { var result = success ? ServiceObjectResult <PaymentResult> .Succeeded(new PaymentResult { PaymentIdentifier = resultReference }) : ServiceObjectResult <PaymentResult> .Failed(null, ""); _paymentExecutionService.Setup(x => x.ExecutePayment(It.Is <PaymentRequest>(request => request.CardNumber == cardNumber))) .ReturnsAsync(result); }
private void SetupRepositorySuccess(DeliveryRecord record) { _mockRepository.Setup(x => x.PutItem(It.IsAny <DeliveryRecord>())) .ReturnsAsync(ServiceResult.Succeeded); _mockRepository.Setup(x => x.GetItems(It.IsAny <ICollection <QueryModel> >())) .ReturnsAsync(ServiceObjectResult <ICollection <DeliveryRecord> > .Succeeded(new List <DeliveryRecord> { record })); _mockRepository.Setup(x => x.GetItems(default))
public async void ExecutePayment_Should_Return_Failed_If_Client_Result_Status_Unrecognised() { _mockBankRequestClient.Setup(x => x.SendPayment(It.IsAny <PaymentRequest>())) .ReturnsAsync(ServiceObjectResult <BankPaymentResponse> .Succeeded(new BankPaymentResponse { PaymentIdentifier = Guid.NewGuid().ToString(), Status = "Unknown" })); var result = await _paymentExecutionService.ExecutePayment(new PaymentRequest()); Assert.False(result.Success); }
public async Task <ServiceObjectResult <ICollection <TDataType> > > GetItems(ICollection <QueryModel> queryModels = null) { var scanConditions = queryModels == null ? new List <ScanCondition>() : queryModels.Select(x => new ScanCondition( x.FieldName, x.Operator, x.Values)).ToList(); var results = await _dynamoDbContext.ScanAsync <TDataType>(scanConditions).GetRemainingAsync(); return(ServiceObjectResult <ICollection <TDataType> > .Succeeded(results)); }
public async void ExecutePayment_Should_Succeed_If_Client_Call_Obtains_Valid_Result() { _mockBankRequestClient.Setup(x => x.SendPayment(It.IsAny <PaymentRequest>())) .ReturnsAsync(ServiceObjectResult <BankPaymentResponse> .Succeeded(new BankPaymentResponse { PaymentIdentifier = Guid.NewGuid().ToString(), Status = PaymentStatus.Complete.ToString() })); var result = await _paymentExecutionService.ExecutePayment(new PaymentRequest()); Assert.True(result.Success); }
private void SetupValidationService(string cardNumber, ICollection <ValidationFieldError> validationErrors) { var result = validationErrors.Any() ? ServiceObjectResult <ICollection <ValidationFieldError> > .Failed(validationErrors, ErrorCodeStrings.BadRequestError) : ServiceObjectResult <ICollection <ValidationFieldError> > .Succeeded(validationErrors); _requestValidator.Setup(x => x.ValidateRequest(It.Is <PaymentRequest>(request => request.CardNumber == cardNumber))) .Returns(result); }
public async Task <ServiceObjectResult <ICollection <DeliveryRecord> > > Select(DeliveryState?state = null) { var result = state.HasValue ? await _repository.GetItems(new List <QueryModel> { new QueryModel(nameof(DeliveryRecord.State), ScanOperator.Equal, state) }) : await _repository.GetItems(); return(result.Success ? ServiceObjectResult <ICollection <DeliveryRecord> > .Succeeded(result.Result) : ServiceObjectResult <ICollection <DeliveryRecord> > .Failed(null, result.Errors)); }