public void SetUp() { _getAccountResponse = _fixture.Create <GetAccountResponse>(); _command = _fixture.Create <CreateApplicationCommand>(); _response = _fixture.Create <CreateApplicationResponse>(); _getStandardResponse = _fixture.Create <GetStandardsListItem>(); _account = _fixture.Create <Account>(); _accountsService = new Mock <IAccountsService>(); _accountsService.Setup(x => x.GetAccount(_command.EncodedAccountId)).ReturnsAsync(_account); _coursesApiClient = new Mock <ICoursesApiClient <CoursesApiConfiguration> >(); _coursesApiClient.Setup(x => x.Get <GetStandardsListItem>(It.Is <GetStandardDetailsByIdRequest>(r => r.Id == _command.StandardId))) .ReturnsAsync(_getStandardResponse); _levyTransferMatchingService = new Mock <ILevyTransferMatchingService>(); _levyTransferMatchingService.Setup(x => x.GetAccount(It.Is <GetAccountRequest>(r => r.AccountId == _command.EmployerAccountId))) .ReturnsAsync(_getAccountResponse); _levyTransferMatchingService.Setup(x => x.CreateApplication(It.IsAny <CreateApplicationRequest>())) .Callback <CreateApplicationRequest>(r => _createApplicationRequest = r) .ReturnsAsync(_response); _handler = new CreateApplicationCommandHandler(_levyTransferMatchingService.Object, _accountsService.Object, Mock.Of <ILogger <CreateApplicationCommandHandler> >(), _coursesApiClient.Object); }
public ActionResult <GetAccountResponse> Get([FromHeader] string client, [FromRoute] string id) { GetAccountResponse response = new GetAccountResponse(); string responseCode = $"GET_ACCOUNT_{client}_{id}"; try { var factory = WalletFactory.Instance.GetAccount(_configuration, true); var account = factory.GetAccount(client, id); if (account == null) { response.StatusCode = "404"; response.Messages.Add(ResponseMessage.Create(responseCode, "account not found.")); return(NotFound(response)); } response.StatusCode = "200"; response.Data = account.Adapt(); return(Ok(response)); } catch (Exception ex) { response.StatusCode = "500"; response.Messages.Add(ResponseMessage.Create(ex, responseCode)); return(StatusCode(500, response)); } }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context) { GetAccountResponse response = new GetAccountResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.TestExpression("cloudwatchRoleArn", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; response.CloudwatchRoleArn = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("throttleSettings", targetDepth)) { var unmarshaller = ThrottleSettingsUnmarshaller.Instance; response.ThrottleSettings = unmarshaller.Unmarshall(context); continue; } } return(response); }
public async Task GetAccountAsync_Should_Return_OkObjectResult_With_GetAccountResponse() { var authResult = AuthorizationResult.Success(); var getAccountTokenOutputQueries = new List <GetAccountTokenOutputQuery> { new GetAccountTokenOutputQuery(DateTimeOffset.UtcNow, DateTimeOffset.UtcNow.AddDays(1), TokenTypeEnumeration.AccountConfirmation, "123456") }; var getAccountOutputQuery = new GetAccountOutputQuery(Guid.NewGuid(), "*****@*****.**", true, DateTimeOffset.UtcNow, true, null, new List <Guid> { Guid.NewGuid() }, getAccountTokenOutputQueries); var accountTokens = getAccountOutputQuery.Tokens.Select(x => new AccountToken(x.Issued, x.Expires, TokenProfile.ConvertToAccountTokenTypeEnum(x.Type), x.Value)); var getAccountResponse = new GetAccountResponse(getAccountOutputQuery.Id, getAccountOutputQuery.Email, getAccountOutputQuery.Confirmed, getAccountOutputQuery.Created, getAccountOutputQuery.PasswordAssigned, getAccountOutputQuery.LastLogin, getAccountOutputQuery.Roles, accountTokens); _authorizationServiceMock .Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <string>())) .ReturnsAsync(authResult); _getAccountQueryHandlerMock .Setup(x => x.HandleAsync(It.IsAny <GetAccountInputQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(getAccountOutputQuery); _mapperMock.Setup(x => x.Map <GetAccountOutputQuery, GetAccountResponse>(It.IsAny <GetAccountOutputQuery>())) .Returns(getAccountResponse); var result = await _controller.GetAccountAsync(getAccountOutputQuery.Id); var okResult = result.As <OkObjectResult>(); okResult.Value.Should().BeEquivalentTo(getAccountResponse); }
public async Task <GetAccountResponse> GetAccount(long playerId) { var response = new GetAccountResponse(); var registeredAccount = await Common1DB.PlayerIds .Where(r => r.playerId == playerId) .Join(Common1DB.Accounts, p => new { AccountType = p.accountType, p.account }, a => new { AccountType = a.type, a.account }, (p, a) => a) .FirstOrDefaultAsync(); if (registeredAccount == null) { // todo: error message throw new NotFoundException("account not exist"); } response.account = new GetAccountResponse.Account { account = registeredAccount.account, type = (int)registeredAccount.type, playerId = registeredAccount.playerId, privilegeLevel = registeredAccount.privilegeLevel, inserted = registeredAccount.inserted, banExpiration = registeredAccount.banExpiration, }; return(response); }
private AccountViewModel Convert(GetAccountResponse response) { return(new AccountViewModel { Id = response.AccountId.ToString(), Name = response.Name }); }
public async Task <CreateEventResponse> CreateEvent(CreateEventRequest request) { GetAccountResponse accountResponse = await this._accountingService.GetAccount(new GetAccountRequest { AccountId = request.AccountId }); EventRelationType relatonType = await this._repositoryEventRelationType.GetBy(t => t.Name == request.EventRelationType); CurrencyType currencyType = await this._repositoryCurrencyType.GetBy(t => t.Name == request.CurrencyType); AlgorithmType algorithmType = await this._repositoryAlgorithmType.GetBy(t => t.Name == request.AlgorithmType); await Check(accountResponse.AccountId, request); using (this._scopeableFactory.Create()) { var arbiterAccountSetResponse = await this._accountingService.CreateAccountsSet( new CreateAccountsSetRequest { CreatorAccountId = accountResponse.AccountId, AccountIds = request.ArbiterAccountIds }); var arbiterAccountSet = await this._repositoryAccountSet.Get(arbiterAccountSetResponse.Id); var participantsAccountSetResponse = await this._accountingService.CreateAccountsSet( new CreateAccountsSetRequest { CreatorAccountId = accountResponse.AccountId, AccountIds = request.ParticipantsAccountIds }); var participantsAccountSet = await this._repositoryAccountSet.Get(participantsAccountSetResponse.Id); var account = await this._repositoryAccount.Get(accountResponse.AccountId); var eventCondition = await this._eventsFactory.CreateEventCondition(account, request.ExpectedEventCondition); var betRateAlgorithm = await this._eventsFactory.CreateEventBetRateAlgorithm(account, algorithmType, request.StartRate, request.EndRate, request.LocusRage); var betCondition = await this._eventsFactory.CreateEventBetCondition(account, currencyType, betRateAlgorithm, request.CloseDate); var @event = await this._eventsFactory.CreateEvent( account, arbiterAccountSet, participantsAccountSet, eventCondition, relatonType, betCondition, request.Title, request.StartDate, request.EndDate); return(new CreateEventResponse { EventId = @event.Id }); } }
public void GetAccountByName_ToLoginInToWebSite_Succeed() { GetAccountNameRequest req = new GetAccountNameRequest(); req.name = "sample"; //mockAccountRepository.Setup(cr => cr.FindByName(It.IsAny<string>())).Returns(req); GetAccountResponse response = accountService.GetAccountByName(req); mockRepository.VerifyAll(); }
private GetAccountResponse FillBaseDetalization(Account account, GetAccountResponse model = null) { model = model ?? new GetAccountResponse(); model.AccountId = account.Id; model.Name = account.Name; model.Email = account.Email; return(model); }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context) { GetAccountResponse response = new GetAccountResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.TestExpression("DedicatedIpAutoWarmupEnabled", targetDepth)) { var unmarshaller = BoolUnmarshaller.Instance; response.DedicatedIpAutoWarmupEnabled = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("Details", targetDepth)) { var unmarshaller = AccountDetailsUnmarshaller.Instance; response.Details = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("EnforcementStatus", targetDepth)) { var unmarshaller = StringUnmarshaller.Instance; response.EnforcementStatus = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("ProductionAccessEnabled", targetDepth)) { var unmarshaller = BoolUnmarshaller.Instance; response.ProductionAccessEnabled = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("SendingEnabled", targetDepth)) { var unmarshaller = BoolUnmarshaller.Instance; response.SendingEnabled = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("SendQuota", targetDepth)) { var unmarshaller = SendQuotaUnmarshaller.Instance; response.SendQuota = unmarshaller.Unmarshall(context); continue; } if (context.TestExpression("SuppressionAttributes", targetDepth)) { var unmarshaller = SuppressionAttributesUnmarshaller.Instance; response.SuppressionAttributes = unmarshaller.Unmarshall(context); continue; } } return(response); }
protected List <AccountResponse> GetResponseFromBuilder(GetAccountRequest req) { RcfProtoChannel channel = (RcfProtoChannel)RPCServiceStub.Channel; RPCServiceStub.GetAccount(null, req, null); GetAccountResponse res = (GetAccountResponse)channel.GetResponse(); if (res != null) { List <AccountResponse> accounts = new List <AccountResponse>(); foreach (var account in res.AccountsList) { AccountResponse foundAccount = new AccountResponse() { account_id = account.AccountId, active = account.Active, username = account.UserName, admin_level = account.AdminLevel, created = new DateTime(account.CreatedTime) }; accounts.Add(foundAccount); foundAccount.characters = new List <Model.Character.CharacterResponse>(); foreach (var character in account.CharactersList) { var charResponse = new Model.Character.CharacterResponse() { account_id = account.AccountId, character_oid = character.ObjectId, firstname = character.FirstName, galaxy_id = character.GalaxyId, galaxy_name = character.GalaxyName, gender = character.Gender, race = character.Race, surname = character.SurName, }; if (character.HasBanned) { charResponse.ban_expiration = new DateTime(character.BanExpiration); charResponse.ban_reason = character.BanReason; charResponse.banned = character.Banned; } foundAccount.characters.Add(charResponse); } } return(accounts); } return(null); }
public async Task Then_The_Api_Is_Called_With_The_Request_And_The_Account_Is_Returned( GetAccountQuery query, GetAccountResponse apiResponse, [Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > apiClient, GetAccountQueryHandler handler ) { apiClient.Setup(x => x.Get <GetAccountResponse>(It.Is <GetAccountRequest>(x => x.HashedAccountId == query.HashedAccountId))).ReturnsAsync(apiResponse); var actual = await handler.Handle(query, CancellationToken.None); actual.Should().BeEquivalentTo(apiResponse); }
public void GetAccount_ToGetAccountById_Success() { GetAccountRequest req = new GetAccountRequest(10) { RequestedBy = 1 }; Account account = AccountMockData.GetAccountClass(); mockAccountRepository.Setup(cr => cr.FindBy(It.IsAny <int>())).Returns(account); GetAccountResponse response = accountService.GetAccount(req); mockRepository.VerifyAll(); Assert.AreEqual(response.AccountViewModel.AccountID, account.Id); Assert.AreEqual(null, response.Exception); }
public void GetAccountUseCaseEqualTest() { GetAccountRequest getAccountRequest = new GetAccountRequest(idUser); IUnitOfWorkFactory unitOfWorkFactory = new UnitOfWorkFactory(); IUnitOfWork unitOfWork = unitOfWorkFactory.CreateUnitOfWork(); unitOfWork.GetAccountsFromDatabase(); IActivityFactory activityFactory = new ActivityFactory(unitOfWork, new ValidationRuleFactory()); IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory); GetAccountResponse getAccountResponse = useCaseFactory.CreateGetAccountUseCase().Execute(getAccountRequest); Assert.AreEqual(getAccountResponse.Account.LastName, lastName); Assert.AreEqual(getAccountResponse.Account.FirstName, firstName); Assert.AreEqual(getAccountResponse.Account.SecondName, secondName); }
public static bool TryReadAccount(GetAccountResponse response, out Account account) { try { using (var stream = new ByteStream(Convert.FromBase64String(response.Account))) { account = stream.ReadAccount(); } } catch { account = null; return(false); } return(true); }
public async Task <GetAccountResponse> GetAccount(GetAccountRequest request) { var name = request.Name; var account = request.AccountId.HasValue ? await this._repositoryAccount.Get(request.AccountId.Value) : await this._repositoryAccount.GetBy(a => a.Name == name); var response = new GetAccountResponse(); if (account != null) { response = await this.GetDetails(account, request.DetalizationLevel); } return(response); }
private async Task <GetProgramResponse> GetProgram(CrmClient client, GetAccountResponse account) { var columnList = await client.GetColumnListAsync("program"); var columnNames = columnList.Row.Columns.Select(c => new Column(c.Key)).ToArray(); var programId = account.Rows[0].Columns["PROGRAMID"].ToString(); var program = await client.GetProgramAsync( "programid = ?", new[] { new ColumnValue("programid", programId) }, columnNames); InferMetaDataToFieldSpecifications(program.MetaData, columnList.Row.Columns); Assert.Single(program.Rows); Assert.Equal("EMPDISC", program.Rows[0].Columns["PROGRAMCODE"]); return(program); }
public async Task VerifyAccountExistsAsync_Should_Return_VerificationResult_With_Success_True() { var accountId = Guid.NewGuid(); const string email = "*****@*****.**"; var account = new GetAccountResponse { Id = accountId, Email = email }; var expectedResult = VerificationResult.Ok(); _rivaIdentityApiClientServiceMock.Setup(x => x.GetAccountAsync(It.IsAny <Guid>())) .ReturnsAsync(account); var result = await _service.VerifyAccountExistsAsync(accountId, email); result.Should().BeEquivalentTo(expectedResult); }
public async Task <IActionResult> GetById(long accountId) { try { var queryResult = await _mediator.Send(new GetAccountQuery { AccountId = accountId }); var returnModel = new GetAccountResponse { HashedAccountId = queryResult.HashedAccountId }; return(Ok(returnModel)); } catch (Exception e) { _logger.LogError(e, "Error getting account by id"); return(BadRequest()); } }
/// <summary> /// Unmarshaller the response from the service to the response class. /// </summary> /// <param name="context"></param> /// <returns></returns> public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context) { GetAccountResponse response = new GetAccountResponse(); context.Read(); int targetDepth = context.CurrentDepth; while (context.ReadAtDepth(targetDepth)) { if (context.TestExpression("Account", targetDepth)) { var unmarshaller = AccountUnmarshaller.Instance; response.Account = unmarshaller.Unmarshall(context); continue; } } return(response); }
public async Task GetAccountAsync_Should_Return_Account() { var accountId = Guid.NewGuid(); var getAccountResponse = new GetAccountResponse { Id = accountId, Email = "*****@*****.**" }; var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(JsonConvert.SerializeObject(getAccountResponse)) }; _httpClientServiceMock.Setup(x => x.GetAsync(It.IsAny <string>())).ReturnsAsync(httpResponseMessage); var result = await _service.GetAccountAsync(accountId); result.Should().BeEquivalentTo(getAccountResponse); }
public ActionResult Index(string submit) { // If a result was passed if (submit == "value1") { HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); // create the response HttpResponseMessage response = client.GetAsync("https://swapi.co/api/starships/10").Result; GetAccountResponse yourcustomobjects = response.Content.ReadAsAsync <GetAccountResponse>().Result; // store the response ViewBag.Message = "Please head to your Starship: " + yourcustomobjects.name.ToString(); } // call the page return(View()); }
public void GetAccount_GetAccountsbyAccountId_Succeed() { AccountsController controller = new AccountsController(mockAccountService.Object, mockWebAnalyticsProviderService.Object); this.SetupControllerTests(controller, "http://localhost/STCRMService/api/accounts/1", HttpMethod.Get); GetAccountResponse response = mockRepository.Create <GetAccountResponse>().Object; response.AccountViewModel = MockData.CreateMockList <AccountViewModel>(mockRepository).Select(c => c.Object).FirstOrDefault(); mockAccountService.Setup(c => c.GetAccount(It.IsAny <GetAccountRequest>())).Returns(response); var httpResponseMessage = controller.GetAccountById(SAMPLE_ACCOUNT_ID); var accountResponse = httpResponseMessage.Content.ReadAsAsync <GetAccountResponse>().ContinueWith( t => { return(t.Result); }).Result; mockRepository.VerifyAll(); Assert.AreEqual(httpResponseMessage.StatusCode, HttpStatusCode.OK); Assert.AreEqual(accountResponse.Exception, null); }
private static string PrepareExpectedResponse(AccountEntity accountEntity) { var accountTokens = accountEntity.Tokens.Select(x => new AccountToken(x.Issued, x.Expires, TokenProfile.ConvertToAccountTokenTypeEnum(x.Type.ConvertToEnumeration()), x.Value)); var getAccountResponse = new GetAccountResponse(accountEntity.Id, accountEntity.Email, accountEntity.Confirmed, accountEntity.Created, !string.IsNullOrWhiteSpace(accountEntity.PasswordHash), accountEntity.LastLogin, accountEntity.Roles.Select(x => x.RoleId), accountTokens); var settings = new JsonSerializerSettings { Formatting = Formatting.Indented, ContractResolver = new DefaultTestPlatformContractResolver { NamingStrategy = new CamelCaseNamingStrategy() }, Converters = new List <JsonConverter> { new StringEnumConverter() } }; return(JsonConvert.SerializeObject(getAccountResponse, settings)); }
public void GetAccount_GetAccountsbyAccountNameRuntimeError_500InternalServerError() { AccountsController controller = new AccountsController(mockAccountService.Object, mockWebAnalyticsProviderService.Object); this.SetupControllerTests(controller, "http://localhost/STCRMService/api/accounts/account1", HttpMethod.Get); var mockResponse = mockRepository.Create <GetAccountResponse>(); GetAccountResponse response = mockRepository.Create <GetAccountResponse>().Object; response.AccountViewModel = MockData.CreateMockList <AccountViewModel>(mockRepository).Select(c => c.Object).FirstOrDefault(); mockAccountService.Setup(cs => cs.GetAccountByName(It.IsAny <GetAccountNameRequest>())).Returns(mockResponse.Object); mockResponse.Setup(r => r.Exception).Returns(new InvalidOperationException()); var httpResponseMessage = controller.GetAccountByName(SAMPLE_ACCOUNT_NAME); var accountResponse = httpResponseMessage.Content.ReadAsAsync <GetAccountResponse>().ContinueWith( t => { return(t.Result); }).Result; var exception = accountResponse.Exception; mockRepository.VerifyAll(); Assert.AreEqual(httpResponseMessage.StatusCode, HttpStatusCode.InternalServerError); Assert.AreNotEqual(exception, null); }
public async Task VerifyAccountExistsAsync_Should_Return_VerificationResult_With_Success_False_When_Email_Do_Not_Match() { var accountId = Guid.NewGuid(); const string email = "*****@*****.**"; var account = new GetAccountResponse { Id = accountId, Email = "*****@*****.**" }; var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.EmailMismatch, AccountErrorMessage.EmailMismatch) }; var expectedResult = VerificationResult.Fail(errors); _rivaIdentityApiClientServiceMock.Setup(x => x.GetAccountAsync(It.IsAny <Guid>())) .ReturnsAsync(account); var result = await _service.VerifyAccountExistsAsync(accountId, email); result.Should().BeEquivalentTo(expectedResult); }
public void GetAccountUseCaseNotEqualTest() { Exception exception = null; try { GetAccountRequest getAccountRequest = new GetAccountRequest(1); IUnitOfWorkFactory unitOfWorkFactory = new UnitOfWorkFactory(); IUnitOfWork unitOfWork = unitOfWorkFactory.CreateUnitOfWork(); unitOfWork.GetAccountsFromDatabase(); IActivityFactory activityFactory = new ActivityFactory(unitOfWork, new ValidationRuleFactory()); IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory); GetAccountResponse getAccountResponse = useCaseFactory.CreateGetAccountUseCase().Execute(getAccountRequest); } catch (Exception ex) { exception = ex; } Assert.AreEqual(exception.Message, "The account is not found!"); }
public async Task <OperationStatusInfo> ShowAccount(int idUser) { return(await Task.Run(() => { OperationStatusInfo operationStatusInfo = new OperationStatusInfo(operationStatus: OperationStatus.Done); GetAccountRequest getAccountRequest = new GetAccountRequest(idUser); try { GetAccountResponse getAccountResponse = hubController.UseCaseFactory.CreateGetAccountUseCase().Execute(getAccountRequest); AccountDTO accountDTO = hubController.TransformAccount(getAccountResponse.Account); operationStatusInfo.AttachedObject = accountDTO; } catch (Exception ex) { Console.WriteLine(ex.Message); operationStatusInfo.OperationStatus = OperationStatus.Cancelled; operationStatusInfo.AttachedInfo = ex.Message; } return operationStatusInfo; })); }
public void ShouldGetAccount() { // Assign var response = new GetAccountResponse { Account = new Account { Id = 2, Name = "Test Account" } }; _mediatorMock.Setup(x => x.SendAsync(It.IsAny <GetAccountRequest>())).ReturnsAsync(response); var expectedContent = JsonConvert.SerializeObject(response.Account); // Act var result = _sut.Get(response.Account.Id); // Assert _mediatorMock.Verify(x => x.SendAsync(It.IsAny <GetAccountRequest>()), Times.Once); result.Result.StatusCode.Should().Be(HttpStatusCode.OK); result.Result.Content.ReadAsStringAsync().Result.Should().Be(expectedContent); }
BattlenetRpcErrorCode HandleGetAccount(GetAccountRequest request, GetAccountResponse response) { Log.outError(LogFilter.ServiceProtobuf, "{0} Client tried to call not implemented method AccountService.GetAccount({1})", GetCallerInfo(), request.ToString()); return(BattlenetRpcErrorCode.RpcNotImplemented); }
public GetAccountResponse GetAccount(string sessionId, string authenticationId) { var response = new GetAccountResponse { IsSuccess = true }; using (new ApplicationContextScope(new ApplicationContext())) { ApplicationContext.SetSessionId(sessionId); try { IAuthenticationProvider authProvider = AuthenticationProviderFactory.GetAuthenticationProvider(); if (authProvider.Validate(authenticationId)) { string accountId = authProvider.GetAccountId(authenticationId); IAccountProvider accountProvider = AccountProviderFactory.GetAccountProvider(); response.UserAccount = accountProvider.GetAccount(accountId).ToDataContract(); return response; } } catch (Exception exception) { response.IsSuccess = false; response.ErrorMessage = exception.Message; Logger.LogException(exception, Source, "GetAccount", Severity.Critical); } } return null; }