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;
}
