public async Task <ActionResult <GetAccountResponse> > Get()
{
var request = new GetAccountRequest
{
AccountId = User.GetAccountId(),
};
var response = await _accountService.GetAsync(request);
if (response.Error == null)
{
return(Ok(response));
}
return(NotFound(response));
}
public Account GetAccount(GetAccountRequest AccountNo)
{
try
{
uow.CreateUnitOfWork();
var res = uow.AccountRepository.GetAccountRequest(AccountNo);
uow.Commit();
return(res);
}
catch (Exception e)
{
throw;
}
}
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 async Task <ActionResult <Account> > GrpcInvoke([FromServices] DaprClient daprClient)
{
_logger.LogDebug("Invoking grpc balance");
var request = new GetAccountRequest()
{
Id = "17",
};
var account = await daprClient.InvokeMethodGrpcAsync <GetAccountRequest, GrpcService.Account>
("grpcsample", "getaccount", request, _cts.Token);
_logger.LogDebug($"Received grpc balance {account.Balance}");
return(new JsonResult(new Account {
Id = account.Id, Balance = account.Balance
}));
}
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 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);
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, ConfirmAccountRequirement requirement)
{
if (!context.User.Identity.IsAuthenticated)
{
return;
}
var request = new GetAccountRequest();
request.SetUserName(context.User.UserName());
var response = await mediator.Send(request);
if (response.EmailConfirmed)
{
context.Succeed(requirement);
}
}
public string CheckFieldDirect(string accName)
{
GetAccountRequest request = new GetAccountRequest();
request.Account = accName;
Response <Account> response = _masterService.GetAccount(request);
if (response.result != null)
{
return("1");
}
else
{
return("0");
}
}
protected void CheckField(object sender, RemoteValidationEventArgs e)
{
TextField field = (TextField)sender;
GetAccountRequest request = new GetAccountRequest();
request.Account = field.Text;
Response <Account> response = _masterService.GetAccount(request);
if (response.Success)
{
e.Success = true;
}
else
{
}
//tbAccountName.ShowIndicator();
}
public async Task <GetAccountResponse> GetAccountAsync(string condition, ColumnValue[] columnValues, Column[] columns, CancellationToken cancellationToken = default)
{
try
{
var request = new GetAccountRequest(_options.CustomerRelationshipManagementOperations.RequestSourceName, condition, columnValues, columns);
var requestXml = request.BuildRequestDocument();
var responseXml = await _executor.ExecuteAsync(requestXml, cancellationToken);
return(new GetAccountResponse(requestXml, responseXml));
}
catch (OracleHospitalityClientException)
{
throw;
}
catch (Exception e)
{
throw new OracleHospitalityClientException($"{RequestCode.Kind.GetAccount} operation failed", e);
}
}
public async Task <GetAccountResponse> GetAccountAsync(ApiAuthentication auth, long accountId)
{
var request = new GetAccountRequest
{
AccountId = accountId,
};
try
{
SetAuthHelper.SetAuth(auth, request);
return(await Check().GetAccountAsync(request));
}
catch (Exception ex)
{
Log(new LogEventArgs(ServiceType.CustomerManagement, "GetAccountAsync", ex.Message, new { Request = request }, ex));
}
return(null);
}
protected void CheckField(object sender, RemoteValidationEventArgs e)
{
TextField field = (TextField)sender;
GetAccountRequest request = new GetAccountRequest();
request.Account = field.Text;
Response <Account> response = _masterService.GetAccount(request);
if (response.Success)
{
e.Success = true;
}
else
{
e.Success = false;
e.ErrorMessage = "Invalid Account";//should access local resources, just didn't figure how yet , only Resources.Common is accessible
}
tbAccountName.ShowIndicator();
}
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 List <AccountResponse> GetAccount(string Username, string password = null)
{
GetAccountRequest req;
if (!string.IsNullOrWhiteSpace(password))
{
req = GetAccountRequest.CreateBuilder()
.SetUserName(Username)
.SetPassword(password)
.SetSearchType(GetAccountRequest.Types.SearchType.ACCOUNTNAME)
.Build();
}
else
{
req = GetAccountRequest.CreateBuilder()
.SetUserName(Username)
.SetSearchType(GetAccountRequest.Types.SearchType.ACCOUNTNAME)
.Build();
}
return(GetResponseFromBuilder(req));
}
public object DirectCheckField(string value)
{
//return true;
GetAccountRequest request = new GetAccountRequest();
request.Account = value;
Response <Account> response = _masterService.GetAccount(request);
if (response.Success)
{
tbAccountName.IndicatorIcon = Icon.Accept;
ResourceManager1.RegisterIcon(Icon.Accept);
}
else
{
tbAccountName.IndicatorIcon = Icon.Error;
ResourceManager1.RegisterIcon(Icon.Error);
}
tbAccountName.ShowIndicator();
return(response.Success);
}
public List <AccountResponse> GetAccount(ulong AccountID, string password = null)
{
GetAccountRequest req;
if (!string.IsNullOrWhiteSpace(password))
{
req = GetAccountRequest.CreateBuilder()
.SetAccountId(Convert.ToUInt32(AccountID))
.SetPassword(password)
.SetSearchType(GetAccountRequest.Types.SearchType.ACCOUNTID)
.Build();
}
else
{
req = GetAccountRequest.CreateBuilder()
.SetAccountId(Convert.ToUInt32(AccountID))
.SetSearchType(GetAccountRequest.Types.SearchType.ACCOUNTID)
.Build();
}
return(GetResponseFromBuilder(req));
}
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 request_generation()
{
const string expected = @"
<CRMMessage language=""en_US"" currency=""DKK"">
<RequestSource name=""acme.com"" version=""1"" />
<RequestCode>GetAccount</RequestCode>
<QueryCriteria conditions=""accountposref = ?"">
<Condition name=""accountposref"" value=""123"" />
</QueryCriteria>
<ResultSetDefinition>
<Column>programid</Column>
</ResultSetDefinition>
</CRMMessage>";
var request =
new GetAccountRequest(
"acme.com",
"accountposref = ?",
new[] { new ColumnValue("accountposref", "123") },
new[] { new Column("programid") });
var requestXml = request.BuildRequestDocument();
Assert.Equal(XE.Parse(expected).ToString(), requestXml.ToString());
}
public async Task <GetAccountResponse> GetAccount(GetAccountRequest request)
{
return(await _levyTransferMatchingApiClient.Get <GetAccountResponse>(request));
}
public Account GetAccountRequest(GetAccountRequest AccountNo)
{
var res = GetWithParamater <Account>(DatabaseConnection.connection, SQLStoredProcedures.getGetAccount, AccountNo, _connection, _transaction);
return(res.SingleOrDefault());
}
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 override void CallServerMethod(uint token, uint methodId, CodedInputStream stream)
{
switch (methodId)
{
case 12:
{
GameAccountHandle request = new GameAccountHandle();
request.MergeFrom(stream);
GameAccountBlob response = new GameAccountBlob();
BattlenetRpcErrorCode status = HandleGetGameAccountBlob(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetGameAccountBlob(GameAccountHandle: {1}) returned GameAccountBlob: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 13:
{
GetAccountRequest request = new GetAccountRequest();
request.MergeFrom(stream);
GetAccountResponse response = new GetAccountResponse();
BattlenetRpcErrorCode status = HandleGetAccount(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetAccount(GetAccountRequest: {1}) returned GetAccountResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 14:
{
CreateGameAccountRequest request = new CreateGameAccountRequest();
request.MergeFrom(stream);
GameAccountHandle response = new GameAccountHandle();
BattlenetRpcErrorCode status = HandleCreateGameAccount(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.CreateGameAccount(CreateGameAccountRequest: {1}) returned GameAccountHandle: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 15:
{
IsIgrAddressRequest request = new IsIgrAddressRequest();
request.MergeFrom(stream);
NoData response = new NoData();
BattlenetRpcErrorCode status = HandleIsIgrAddress(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.IsIgrAddress(IsIgrAddressRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 20:
{
CacheExpireRequest request = new CacheExpireRequest();
request.MergeFrom(stream);
BattlenetRpcErrorCode status = HandleCacheExpire(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.CacheExpire(CacheExpireRequest: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
case 21:
{
CredentialUpdateRequest request = new CredentialUpdateRequest();
request.MergeFrom(stream);
CredentialUpdateResponse response = new CredentialUpdateResponse();
BattlenetRpcErrorCode status = HandleCredentialUpdate(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.CredentialUpdate(CredentialUpdateRequest: {1}) returned CredentialUpdateResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 25:
{
SubscriptionUpdateRequest request = new SubscriptionUpdateRequest();
request.MergeFrom(stream);
SubscriptionUpdateResponse response = new SubscriptionUpdateResponse();
BattlenetRpcErrorCode status = HandleSubscribe(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.Subscribe(SubscriptionUpdateRequest: {1}) returned SubscriptionUpdateResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 26:
{
SubscriptionUpdateRequest request = new SubscriptionUpdateRequest();
request.MergeFrom(stream);
NoData response = new NoData();
BattlenetRpcErrorCode status = HandleUnsubscribe(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.Unsubscribe(SubscriptionUpdateRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 30:
{
GetAccountStateRequest request = new GetAccountStateRequest();
request.MergeFrom(stream);
GetAccountStateResponse response = new GetAccountStateResponse();
BattlenetRpcErrorCode status = HandleGetAccountState(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetAccountState(GetAccountStateRequest: {1}) returned GetAccountStateResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 31:
{
GetGameAccountStateRequest request = new GetGameAccountStateRequest();
request.MergeFrom(stream);
GetGameAccountStateResponse response = new GetGameAccountStateResponse();
BattlenetRpcErrorCode status = HandleGetGameAccountState(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetGameAccountState(GetGameAccountStateRequest: {1}) returned GetGameAccountStateResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 32:
{
GetLicensesRequest request = new GetLicensesRequest();
request.MergeFrom(stream);
GetLicensesResponse response = new GetLicensesResponse();
BattlenetRpcErrorCode status = HandleGetLicenses(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetLicenses(GetLicensesRequest: {1}) returned GetLicensesResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 33:
{
GetGameTimeRemainingInfoRequest request = new GetGameTimeRemainingInfoRequest();
request.MergeFrom(stream);
GetGameTimeRemainingInfoResponse response = new GetGameTimeRemainingInfoResponse();
BattlenetRpcErrorCode status = HandleGetGameTimeRemainingInfo(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetGameTimeRemainingInfo(GetGameTimeRemainingInfoRequest: {1}) returned GetGameTimeRemainingInfoResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 34:
{
GetGameSessionInfoRequest request = new GetGameSessionInfoRequest();
request.MergeFrom(stream);
GetGameSessionInfoResponse response = new GetGameSessionInfoResponse();
BattlenetRpcErrorCode status = HandleGetGameSessionInfo(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetGameSessionInfo(GetGameSessionInfoRequest: {1}) returned GetGameSessionInfoResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 35:
{
GetCAISInfoRequest request = new GetCAISInfoRequest();
request.MergeFrom(stream);
GetCAISInfoResponse response = new GetCAISInfoResponse();
BattlenetRpcErrorCode status = HandleGetCAISInfo(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetCAISInfo(GetCAISInfoRequest: {1}) returned GetCAISInfoResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 36:
{
ForwardCacheExpireRequest request = new ForwardCacheExpireRequest();
request.MergeFrom(stream);
NoData response = new NoData();
BattlenetRpcErrorCode status = HandleForwardCacheExpire(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.ForwardCacheExpire(ForwardCacheExpireRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 37:
{
GetAuthorizedDataRequest request = new GetAuthorizedDataRequest();
request.MergeFrom(stream);
GetAuthorizedDataResponse response = new GetAuthorizedDataResponse();
BattlenetRpcErrorCode status = HandleGetAuthorizedData(request, response);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetAuthorizedData(GetAuthorizedDataRequest: {1}) returned GetAuthorizedDataResponse: {2} status: {3}.",
GetCallerInfo(), request.ToString(), response.ToString(), status);
if (status == 0)
{
SendResponse(token, response);
}
else
{
SendResponse(token, status);
}
break;
}
case 38:
{
AccountFlagUpdateRequest request = new AccountFlagUpdateRequest();
request.MergeFrom(stream);
BattlenetRpcErrorCode status = HandleAccountFlagUpdate(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.AccountFlagUpdate(AccountFlagUpdateRequest: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
case 39:
{
GameAccountFlagUpdateRequest request = new GameAccountFlagUpdateRequest();
request.MergeFrom(stream);
BattlenetRpcErrorCode status = HandleGameAccountFlagUpdate(request);
Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GameAccountFlagUpdate(GameAccountFlagUpdateRequest: {1}) status: {2}.",
GetCallerInfo(), request.ToString(), status);
if (status != 0)
{
SendResponse(token, status);
}
break;
}
/* case 40:
* {
* UpdateParentalControlsAndCAISRequest request = new UpdateParentalControlsAndCAISRequest();
* request.MergeFrom(stream);
*
* NoData response = new NoData();
* BattlenetRpcErrorCode status = HandleUpdateParentalControlsAndCAIS(request, response);
* Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.UpdateParentalControlsAndCAIS(UpdateParentalControlsAndCAISRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
* GetCallerInfo(), request.ToString(), response.ToString(), status);
* if (status == 0)
* SendResponse(token, response);
* else
* SendResponse(token, status);
* break;
* }
* case 41:
* {
* CreateGameAccountRequest request = new CreateGameAccountRequest();
* request.MergeFrom(stream);
*
* CreateGameAccountResponse response = new CreateGameAccountResponse();
* BattlenetRpcErrorCode status = HandleCreateGameAccount2(request, response);
* Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.CreateGameAccount2(CreateGameAccountRequest: {1}) returned CreateGameAccountResponse: {2} status: {3}.",
* GetCallerInfo(), request.ToString(), response.ToString(), status);
* if (status == 0)
* SendResponse(token, response);
* else
* SendResponse(token, status);
* break;
* }
* case 42:
* {
* GetGameAccountRequest request = new GetGameAccountRequest();
* request.MergeFrom(stream);
*
* GetGameAccountResponse response = new GetGameAccountResponse();
* BattlenetRpcErrorCode status = HandleGetGameAccount(request, response);
* Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.GetGameAccount(GetGameAccountRequest: {1}) returned GetGameAccountResponse: {2} status: {3}.",
* GetCallerInfo(), request.ToString(), response.ToString(), status);
* if (status == 0)
* SendResponse(token, &response);
* else
* SendResponse(token, status);
* break;
* }
* case 43:
* {
* QueueDeductRecordRequest request = new QueueDeductRecordRequest();
* request.MergeFrom(stream);
*
* NoData response = new NoData();
* BattlenetRpcErrorCode status = HandleQueueDeductRecord(request, response);
* Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method AccountService.QueueDeductRecord(QueueDeductRecordRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.",
* GetCallerInfo(), request.ToString(), response.ToString(), status);
* if (status == 0)
* SendResponse(token, response);
* else
* SendResponse(token, status);
* break;
* }*/
default:
Log.outError(LogFilter.ServiceProtobuf, "Bad method id {0}.", methodId);
SendResponse(token, BattlenetRpcErrorCode.RpcInvalidMethod);
break;
}
}
public Task <AccountResponse> GetAccountAsync(GetAccountRequest Address) => GetSimpleJsonAsync <AccountResponse, GetAccountRequest>(Address, Api.GetAccount);
public AccountResponse GetAccount(GetAccountRequest Address) => GetAccountAsync(Address).ConfigureAwait(false).GetAwaiter().GetResult();
public async Task <IActionResult> GetAccountDetail([FromBody] GetAccountRequest request)
{
try
{
_logger.LogInformation("Get account number(Account Number: {AccountNumber}) with account type {AccountType}.", request.AccountNumber, request.AccountPIN);
//validate parameters
if (request.AccountNumber.Length == 0)
{
_logger.LogInformation("No account number found from request.");
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.OK),
Message = Convert.ToString(HttpStatusCode.OK),
Payload = new GetAccountResponsePayload()
{
MessageDetail = "No account number found."
}
}));
}
if (request.AccountPIN.Length == 0)
{
_logger.LogInformation("No account PIN found from request.");
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.OK),
Message = Convert.ToString(HttpStatusCode.OK),
Payload = new GetAccountResponsePayload()
{
MessageDetail = "No account PIN found."
}
}));
}
//call query handler
var query = new GetAccountQuery(request.AccountNumber, request.AccountPIN);
var queryResult = await _mediator.Send(query);
return(new JsonResult(new GetAccountResponse()
{
StatusCode = queryResult.StatusCode,
Message = queryResult.Message,
MessageDetail = queryResult.MessageDetails,
Payload = new GetAccountResponsePayload()
{
AcctId = queryResult.AcctId,
FirstName = queryResult.FirstName,
MiddleName = queryResult.MiddleName,
LastName = queryResult.LastName,
AccountNumber = queryResult.AccountNumber,
AccountPIN = queryResult.AccountPIN,
AccountType = queryResult.AccountType,
AccountStatus = queryResult.AccountStatus,
InitialAmountDeposit = queryResult.InitialAmountDeposit,
DateCreated = queryResult.DateCreated,
DateUpdated = queryResult.DateUpdated,
MessageDetail = queryResult.MessageDetails
}
}));
}
catch (Exception ex)
{
_logger.LogError("Get account number request failed. Exception error message: {exceptionMessage}", ex.ToString());
return(new JsonResult(new GetAccountResponse()
{
StatusCode = Convert.ToInt32(HttpStatusCode.BadRequest),
Message = Convert.ToString(HttpStatusCode.BadRequest),
MessageDetail = "Get contact group list request failed. Exception error message: " + ex.ToString()
}));
}
}
public async Task <GetAccountResponse> GetAccount(GetAccountRequest request, string jwtToken)
{
return(await PolicyHelper.ThreeRetriesAsync().ExecuteAsync(() =>
_bankService.BaseAddress.AppendPathSegments(_bankService.BankPath.Account, request.Id)
.WithOAuthBearerToken(jwtToken).GetJsonAsync <GetAccountResponse>()));
}
public Account GetAccount(GetAccountRequest getAccountRequest)
{
return(_accountService.GetAccount(getAccountRequest));
}
/// <summary>
/// Initiates the asynchronous execution of the GetAccount operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetAccount operation on AmazonAPIGatewayClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAccount
/// operation.</returns>
public IAsyncResult BeginGetAccount(GetAccountRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetAccountRequestMarshaller();
var unmarshaller = GetAccountResponseUnmarshaller.Instance;
return BeginInvoke<GetAccountRequest>(request, marshaller, unmarshaller,
callback, state);
}
internal GetAccountResponse GetAccount(GetAccountRequest request)
{
var marshaller = new GetAccountRequestMarshaller();
var unmarshaller = GetAccountResponseUnmarshaller.Instance;
return Invoke<GetAccountRequest,GetAccountResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Returns the account requested by account ID.
/// </summary>
/// <param name="accountId"></param>
/// <returns></returns>
private async Task<Account> GetAccountAsync(long accountId)
{
var request = new GetAccountRequest
{
AccountId = accountId
};
return (await Service.CallAsync((s, r) => s.GetAccountAsync(r), request)).Account;
}
/// <summary>
/// Initiates the asynchronous execution of the GetAccount operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetAccount operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<GetAccountResponse> GetAccountAsync(GetAccountRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetAccountRequestMarshaller();
var unmarshaller = GetAccountResponseUnmarshaller.Instance;
return InvokeAsync<GetAccountRequest,GetAccountResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
public string Authenticate(string accountName, string userName, string password)
{
GetAccountRequest GetACrequest = new GetAccountRequest();
GetACrequest.Account = tbAccountName.Text;
Response <Account> getACResponse = _masterService.GetAccount(GetACrequest);
if (!getACResponse.Success)
{
lblError.Text = getACResponse.Error;
return("error");//Error in authentication
}
_systemService.SessionHelper.Set("AccountId", getACResponse.result.accountId);
AuthenticateRequest request = new AuthenticateRequest();
request.UserName = tbUsername.Text;
request.Password = EncryptionHelper.encrypt(tbPassword.Text);
AuthenticateResponse response = _systemService.Authenticate(request);
if (response.User == null)
{
if (string.IsNullOrEmpty(response.Error))
{
lblError.Text = GetGlobalResourceObject("Errors", "authenticationError").ToString();
}
else
{
lblError.Text = response.Error;
}
return("error");
}
if ((ActiveStatus)response.User.activeStatus == ActiveStatus.INACTIVE)
{
lblError.Text = GetGlobalResourceObject("Errors", "inactiveUser").ToString();
return("error");
}
if (response.Success)
{
//Redirecting..
Response.Cookies.Add(new HttpCookie("accountName", accountName)
{
Expires = DateTime.Now.AddDays(30)
});
if (rememberMeCheck.Checked)
{
Response.Cookies.Add(new HttpCookie("email")
{
Value = userName, Expires = DateTime.Now.AddDays(30),
});
Response.Cookies.Add(new HttpCookie("password")
{
Value = password, Expires = DateTime.Now.AddDays(30),
});
}
else
{
RemoveCookies();
}
//switch (response.User.languageId)
//{
// case 1: _systemService.SessionHelper.SetLanguage("en");
// break;
// case 2:
// _systemService.SessionHelper.SetLanguage("ar");
// break;
// case 3: _systemService.SessionHelper.SetLanguage("fr");
// break;
// default: _systemService.SessionHelper.SetLanguage("en");
// break;
//}
_systemService.SessionHelper.SetLanguage("de");
_systemService.SessionHelper.Set("CompanyName", getACResponse.result.companyName);
_systemService.SessionHelper.SetUserType(response.User.userType);
_systemService.SessionHelper.SetEmployeeId(response.User.employeeId);
_systemService.SessionHelper.Set("CurrentUserName", userName);
_systemService.SessionHelper.Set("IsAdmin", response.User.isAdmin);
StoreSystemDefaults();
return("1");//Succeded
}
else
{
lblError.Text = response.Error;
return("error");//Error in authentication
}
}
