public async void Run_TransactionHistoryTest()
{
ShowTestOnTerminal("TransactionHistory");
AuthorizationRequest setupRequest = new AuthorizationRequest
{
Pan = "4111111111111111",
ExpMonth = "12",
ExpYear = "2025",
Amount = "25.55",
Test = true,
TransactionRef = Guid.NewGuid().ToString("N"),
};
output.WriteLine("Setup request: {0}", setupRequest);
AuthorizationResponse setupResponse = await blockchyp.ChargeAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
TransactionHistoryRequest request = new TransactionHistoryRequest
{
MaxResults = 10,
};
output.WriteLine("Request: {0}", request);
TransactionHistoryResponse response = await blockchyp.TransactionHistoryAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
}
/// <summary>
/// Get transaction history from user account. For use, must authorize User.
/// </summary>
/// <param name="body">Transaction history body request.</param>
/// <returns>Transaction history object.</returns>
/// <exception cref="ArgumentException">Throw when body parameter is null.</exception>
public TransactionHistory GetTransactionHistory(TransactionHistoryRequest body)
{
if (body == null)
{
throw new ArgumentException("The body params can not be null!");
}
return(SendGetTransactionHistoryRequest(body));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public TransactionHistoryResponse TransactionHistory(TransactionHistoryRequest request)
{
TransactionHistoryResponse response = new TransactionHistoryResponse();
string requestMessage = request.Serialize();
MQAdapter mqAdapter = new MQAdapter(_adapter);
string responseMessage = mqAdapter.SendMQRequestSync(requestMessage);
response.DeSerialize(responseMessage);
return(response);
}
TransactionHistory SendGetTransactionHistoryRequest(TransactionHistoryRequest body)
{
RestClient rc = new RestClient(config.ApiTradingUrl + "history/transactions");
rc.AddQuery(body);
rc.AddOwnHeaderToRequest(new AutorizeData(config));
rc.SendGET();
return(Tools.TryGetResponse <TransactionHistory>(rc));
}
public IHttpActionResult TransactionHistory(string accountNo, string country, string currency)
{
DateTime startDate = new DateTime(2014, 01, 01);
DateTime endDate = DateTime.Now;
//Temp
string sdate = String.Format("{0:00}", startDate.Day) +
String.Format("{0:00}", startDate.Month) + startDate.Year.ToString().Substring(2, 2);
string edate = String.Format("{0:00}", endDate.Day) +
String.Format("{0:00}", endDate.Month) + endDate.Year.ToString().Substring(2, 2);
string environment = System.Configuration.ConfigurationManager.AppSettings["Environment." + country];
EquationAdapter adapter = new EquationAdapter();
Dictionary <string, string> dictionary = this.TransactionCodes(country);
TransactionHistoryRequest request = new TransactionHistoryRequest();
request.TransactionHeader = new TransactionHeader(country, environment, "1", 1);
request.Currency = currency;
request.AccountBranch = accountNo.Substring(0, 4);
request.AccountBasicNo = accountNo.Substring(4, 6);
request.AccountSuffix = accountNo.Substring(10, 3);
request.StartDate = sdate;
request.EndDate = edate;
request.MarketSegment = "00";
request.ServicePackage = "00";
TransactionHistoryResponse response = adapter.TransactionHistory(request);
if (response.ResponseCode == Constants.Equation_Success)
{
foreach (Transaction transaction in response.Transactions)
{
if (dictionary.ContainsKey(transaction.Code))
{
transaction.Description = dictionary[transaction.Code].ToString();
}
else
{
transaction.Description = transaction.Code;
}
}
return(Json(response));
}
else
{
throw new HttpRequestException(response.ResponseDescription);
}
}
public async Task <ActionResult <IEnumerable <HistoricalTransactionContract> > > GetIncomingHistory(
TransactionHistoryRequest request)
{
var address = request.Address.ToLowerInvariant();
var transactions = await _transactionHistoryService.GetIncomingHistoryAsync
(
address,
request.Take,
request.AfterHash
);
return(Ok(await transactions.SelectAsync(ConvertToHistoricalTransactionContractAsync)));
}
public void GetTransactionHistoryTest()
{
TransactionHistoryRequest request = new TransactionHistoryRequest();
request.Markets.Add("BTC-PLN");
try
{
history = bbClient.History.GetTransactionHistory(request);
}
catch (FailResponseException e)
{
Tools.HandlingErrors(e);
return;
}
Assert.IsNotNull(history);
if (history.Transactions.Count > 0)
{
Assert.AreEqual("BTC-PLN", history.Transactions[0].Market);
}
}
//public KeyValuePair<string, List<TransactionHistory>> GetTransactionHistoryRecord(int page, int pageSize, string whereCondition, string sort)
//{
//}
public KeyValuePair <string, List <TransactionHistory> > GetTransactionHistoryRecord(string recordID, int page, int pageSize, TransactionHistoryRequest model, string sort)
{
try
{
TransactionHistory transactionHistory = new TransactionHistory();
int airlinesno = model.AirlineSNo;
int citysno = model.CitySNo;
int officesno = model.OfficeSNo;
int accountsno = model.AccountSNo;
SqlParameter[] Parameters = { new SqlParameter("@PageNo", page), new SqlParameter("@PageSize", pageSize),
new SqlParameter("@airlinesno", airlinesno),
new SqlParameter("@citysno", citysno),
new SqlParameter("@officesno", officesno),
new SqlParameter("@accountsno", accountsno),
new SqlParameter("@OrderBy", sort) };
DataSet ds = SqlHelper.ExecuteDataset(DMLConnectionString.WebConfigConnectionString, CommandType.StoredProcedure, "GetListTransactionHistory", Parameters);
var TransactionHistoryList = ds.Tables[0].AsEnumerable().Select(e => new TransactionHistory
{
SNo = Convert.ToInt32(e["SNo"]),
Text_AirlineSNo = e["Text_AirlineSNo"].ToString(),
AgentName = e["AgentName"].ToString(),
AgentCode = e["AgentCode"].ToString(),
Text_CitySNo = e["Text_CitySNo"].ToString(),
Text_OfficeSNo = e["Text_OfficeSNo"].ToString(),
Text_CurrencySNo = e["Text_CurrencySNo"].ToString(),
Amount = Convert.ToDouble(e["Amount"]),
Text_TransactionType = e["Text_TransactionType"].ToString(),
TransactionDate = Convert.ToString(e["TransactionDate"] == null ? "" : e["TransactionDate"]),
AccountNo = e["AccountNo"].ToString(),
});
return(new KeyValuePair <string, List <TransactionHistory> >(
ds.Tables[1].Rows[0][0].ToString(), TransactionHistoryList.AsQueryable().ToList()));
}
catch (Exception ex)//
{
throw ex;
}
}
public static async Task <TransactionHistoryResponse> TransactionHistoryApi(TransactionHistoryRequest request)
{
return(await CustomHttpClient.Post <TransactionHistoryResponse>(request, "/GetHistoryList"));
}
