private async Task <CheckStatusReply> CheckCurrentServerStatus()
{
var checkStatusRequest = new CheckStatusRequest();
checkStatusRequest.ServerId.Add(this.ServerId);
return(await CheckStatusAsync(checkStatusRequest));
}
public async Task <IActionResult> Handle(HttpRequest request, CheckStatusRequest data)
{
AuthByKeyResult authResult = this.GetAuthenticationKey(request);
if (!authResult.Result)
{
return(new JsonErrorResult(authResult.ErrorResponse));
}
ErrorResponse validationError = this.ValidateRequest(data);
if (validationError != null)
{
return(new JsonErrorResult(validationError));
}
try
{
using (SqlConnection conn = sqlServer.GetConnection())
{
await conn.OpenAsync();
using (SqlCommand cmd = sqlServer.GetSpCommand("dbo.Employee_CheckEmployeeStatus", conn))
{
cmd.AddBinaryParam("@PermanentKey", 16, authResult.Key.ToArray());
cmd.AddIntParam("@PlaceId", data.PlaceId);
SqlParameter EmployeeIdParam = cmd.AddIntParam("@EmployeeId").Output();
SqlParameter EmployeeFirstNameParam = cmd.AddNVarCharParam("@EmployeeFirstName", 50).Output();
SqlParameter EmployeeLastNameParam = cmd.AddNVarCharParam("@EmployeeLastName", 50).Output();
SqlParameter EmployeeIsDisabledParam = cmd.AddBitParam("@EmployeeIsDisabled").Output();
SqlParameter PlaceGroupIdParam = cmd.AddIntParam("@PlaceGroupId").Output();
SqlParameter PlaceGroupNameParam = cmd.AddNVarCharParam("@PlaceGroupName", 50).Output();
SqlParameter retValParam = cmd.AddReturnValue();
await cmd.ExecuteNonQueryAsync();
int retVal = retValParam.GetInt32OrDefault();
if (retVal == -1)
{
return(this.GetAuthKeyNotFoundResponse());
}
CheckStatusResponse response = new CheckStatusResponse();
response.EmployeeId = EmployeeIdParam.GetInt32OrDefault();
response.EmployeeFirstName = EmployeeFirstNameParam.Value.ToString();
response.EmployeeLastName = EmployeeLastNameParam.Value.ToString();
response.EmployeeIsDisabled = EmployeeIsDisabledParam.GetBooleanOrDefault();
response.PlaceGroupId = PlaceGroupIdParam.GetInt32OrNull();
response.PlaceGroupName = PlaceGroupNameParam.GetStringOrNull();
return(new JsonResult(response));
}
}
}
catch (Exception ex)
{
return(new JsonErrorResult(this.GetExceptionResponse(ex)));
}
}
/* ====================================================================== */
/* ====[ Auxiliary Remote Calls ]==== */
/* ====================================================================== */
public async Task <CheckStatusReply> CheckStatusAsync(CheckStatusRequest request)
{
CheckStatusReply reply = new CheckStatusReply(); // empty reply
try
{
Console.WriteLine($"Checking status of server {this.ServerId}.");
// Connect to random serverId (hopefully one that isnt down) and check the status of the suspicious ones
var random = new Random();
var index = random.Next(_serversCount);
var newServerId = _servers.Keys.ElementAt(index);
Console.WriteLine($"Establish a channel with a random server (id: {newServerId}).");
EstablishChannel(newServerId);
await _client.CheckStatusAsync(request);
}
catch (RpcException e)
{
Console.WriteLine($"RpcException: {e.StatusCode}");
// Exception -> the newServer is also suspicious
request.ServerId.Add(this.ServerId);
await CheckStatusAsync(request); // recursion
}
return(reply);
}
public IActionResult RequestStatus([FromBody] CheckStatusRequest checkStatusRequest)
{
using (var httpClient = new HttpClient())
{
var requestStatusUri = string.Format("http://provisioningportal:5000/api/requeststatus/{0}", checkStatusRequest.Inputs.RequestId);
var response = httpClient.GetAsync(requestStatusUri).Result;
var responseContent = response.Content.ReadAsStringAsync().Result;
var checkStatusReponse = new CheckStatusResponse(responseContent);
return(new ObjectResult(checkStatusReponse));
}
}
public IActionResult CheckTransactionStatus([FromBody] CheckStatusRequest request)
{
ConfirmPaymentResponse response = new ConfirmPaymentResponse();
response.TransactionStatus = 1;
response.AdditionalInfo = "string information" + "\n" + "Basic Info:" + request.BasicInfo.ToString();
response.TransactionId = request.TransactionId;
response.CurrentBalance = 200.36;
response.CompletionDateTime = DateTime.Now.ToString(Constants.Constants.DateTimeFormat);
response.TotalAmount = 50.6;
response.CurrencyCode = "SAR";
return(Ok(response));
}
public void Can_query_processing_online_deposit_status()
{
var request = new CheckStatusRequest
{
TransactionNumber = "XP-0-20151202154756"
};
var response = _depositQueries.CheckStatus(request);
response.IsPaid.Should().Be(false, "IsPaid");
response.Amount.Should().Be(0, "Amount");
response.Bonus.Should().Be(0, "Bonus");
response.TotalAmount.Should().Be(0, "TotalAmount");
}
public IActionResult CheckTransactionStatus([FromBody] CheckStatusRequest request)
{
if (!request.ValidateObject())
{
try
{
ExceptionHandeling.FireError((int)ErrorCode.General_Error, (int)GeneralError.Nullable_Request, Constants.Constants.GeneralErrorDic[GeneralError.Nullable_Request]);
}
catch (CodeLabException codelabExp)
{
return(ExceptionHandeling.GenerateErrorResponse(codelabExp));
}
}
ConfirmPaymentResponse response = new ConfirmPaymentResponse();
TransactionRep transactionRep = new TransactionRep(Context);
AccountRep accountRep = new AccountRep(Context);
Account account = accountRep.GetByMSDIN(request.BasicInfo.MobileNumberInfo.Number);
Transaction transaction = transactionRep.GetByTransactionID(request.TransactionId);
//Question
try
{
if (account != null)
{
if (transaction != null)
{
response.TransactionStatus = 1;
response.AdditionalInfo = "string information" + "\n" + "Basic Info:" + request.BasicInfo.ToString();
response.TransactionId = transaction.TransactionId;
response.CurrentBalance = (double)account.Balance;
response.CompletionDateTime = transaction.IssueTime.ToString(Constants.Constants.DateTimeFormat);
response.TotalAmount = (double)transaction.Amount;
response.CurrencyCode = transaction.CurrencyCode;
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Payment_Error, (int)PaymentError.Transaction_Id_Not_Exist, Constants.Constants.PaymentErrorDic[PaymentError.Transaction_Id_Not_Exist]);
}
}
else
{
ExceptionHandeling.FireError((int)ErrorCode.Wrong_Input_Error, (int)WrongInputError.Wrong_Wallet_Number, Constants.Constants.WrongInputDic[WrongInputError.Wrong_Wallet_Number]);
}
}
catch (CodeLabException codelabExp)
{
return(ExceptionHandeling.GenerateErrorResponse(codelabExp));
}
return(Ok(response));
}
public void Can_query_approved_online_deposit_status()
{
var request = new CheckStatusRequest
{
TransactionNumber = _approvedOnlineDeposit.TransactionNumber
};
var response = _depositQueries.CheckStatus(request);
response.IsPaid.Should().Be(true, "IsPaid");
response.Amount.Should().Be(_approvedOnlineDeposit.Amount, "Amount");
//TODO:ONLINEDEPOSIT wait for Bonus function
//response.Bonus.Should().Be(0, "Bonus");
//response.TotalAmount.Should().Be(0, "TotalAmount");
}
public ConfirmPaymentResponse CheckTransactionStatus(CheckStatusRequest request)
{
HttpResponseMessage response = MockupsAPIsCaller.CallAPI(request, "api/Payment/MerchantToSR/CheckTransactionStatus");
if (response.StatusCode == HttpStatusCode.OK)
{
string ResponseString = (response.Content.ReadAsStringAsync()).Result;
ConfirmPaymentResponse confirmPaymentResponse = JsonConvert.DeserializeObject <ConfirmPaymentResponse>(ResponseString);
return(confirmPaymentResponse);
}
else if (response.StatusCode == (HttpStatusCode)490)
{
throw MockupsAPIsCaller.GenerateError(response);
}
throw new Exception();
}
static void Main(string[] args)
{
List<string> listAcc = File.ReadAllLines("00.txt").ToList();
Parallel.ForEach(listAcc, new ParallelOptions()
{
MaxDegreeOfParallelism = 1
}, (Mssv) =>
{
using (CheckStatusRequest vnu = new CheckStatusRequest())
{
vnu.User = Mssv;
vnu.Pass = Mssv;
vnu.Begin();
}
});
Console.ReadKey();
}
public CheckStatusResponse CheckStatus(CheckStatusRequest request)
{
var depositStatus = new CheckStatusResponse
{
IsPaid = false
};
var onlineDeposit = _repository.OnlineDeposits.FirstOrDefault(x => x.TransactionNumber == request.TransactionNumber);
if (onlineDeposit != null)
{
var onlineDepositEntity = new OnlineDeposit(onlineDeposit);
if (onlineDepositEntity.IsApproved())
{
depositStatus.IsPaid = true;
depositStatus.Amount = onlineDeposit.Amount;
depositStatus.Bonus = 0;//TODO:ONLINEDEPOSIT how to get Bonus
depositStatus.TotalAmount = depositStatus.Amount + depositStatus.Bonus;
}
}
return(depositStatus);
}
/* ====================================================================== */
/* ====[ Auxilliary ]==== */
/* ====================================================================== */
public override async Task <CheckStatusReply> CheckStatus(CheckStatusRequest request, ServerCallContext context)
{
// Add requested server ids to a Set, to remove all duplicates
var ids = new HashSet <string>(request.ServerId.Count);
foreach (var serverId in request.ServerId)
{
ids.Add(serverId);
}
// Check the status of each server id
foreach (var serverId in ids)
{
Console.WriteLine($"Checking status of server {serverId}...");
await _gigaStorage.CheckStatusAsync(serverId);
}
return(await Task.FromResult(new CheckStatusReply
{
// Empty message as ack
}));
}
public bool CheckStatus(CheckStatusRequest checkStatus)
{
throw new NotImplementedException();
}
private ErrorResponse ValidateRequest(CheckStatusRequest data)
{
ApiValidator.ValidatePlaceId(data.PlaceId, out ErrorResponse error);
return(error);
}
public async Task <IActionResult> CheckEmployeeStatus(CheckStatusRequest data)
{
return(await GetHandler <CheckEmployeeStatus>().Handle(this.Request, data));
}
/// <summary>
/// Check status
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
public Task <CheckStatusResponse> CheckStatus(CheckStatusRequest request, CancellationToken token = default)
{
return(Task.FromResult(new CheckStatusResponse {
Status = Status
}));
}
public async Task <ApiResponse <CheckStatusResponse> > CheckEmployeeStatus(CheckStatusRequest data)
{
data.ClientInfo = this._clientInfo;
return(await new ApiMethod <CheckStatusRequest, CheckStatusResponse>(
this._httpClient, this._controllerUriPart, "CheckStatus", AuthHeaderKind.Regular).Call(data));
}
