//Get Transaction
public async Task <PaymentResponse> GetTransaction(GetTransactionRequest req)
{
string jsonRequest = CommonService.JsonSerializer <GetTransactionRequest>(req);
string jsonResponse = await PostRequest(jsonRequest, "gettransaction", req.Id);
return(CommonService.JsonDeSerializer <PaymentResponse>(jsonResponse));
}
public async Task <FulfillmentResponse> FulfillAsync(FulfillmentRequest fulfillmentRequest, IJobberClient jobberClient)
{
var datePeriod = GetDatePeriodForRevenueFrom(fulfillmentRequest);
var timeUnit = fulfillmentRequest.GetParameter(Constants.Variables.TimeUnitOriginal);
if (string.IsNullOrEmpty(timeUnit))
{
timeUnit = "last week";
}
var getTransactionRequest = new GetTransactionRequest
{
Start = datePeriod.Start,
End = datePeriod.End,
TimeUnit = timeUnit
};
var Transactions = await jobberClient.GetRangedTransactionsAsync(getTransactionRequest);
decimal revenue = Transactions.GetTotal();
if (timeUnit.EndsWith("?"))
{
timeUnit = timeUnit.Remove(timeUnit.Length - 1);
}
return(FulfillmentResponseBuilder.Create()
.Speech($"We made ${revenue.ToString("N")} {timeUnit}")
.Build());
}
/// <summary>
/// Look up an existing transaction and return the response.
/// </summary>
/// <param name="accountId">the account id</param>
/// <param name="transactionId">the transaction id</param>
/// <param name="keyLevel">the key level</param>
/// <returns>the transaction</returns>
/// <exception cref="StepUpRequiredException">if further authentication is required</exception>
public Task <Transaction> GetTransaction(
string accountId,
string transactionId,
Level keyLevel)
{
var request = new GetTransactionRequest
{
AccountId = accountId,
TransactionId = transactionId
};
return(gateway(authenticateOnBehalfOf(keyLevel)).GetTransactionAsync(request)
.ToTask(response =>
{
switch (response.Status)
{
case RequestStatus.SuccessfulRequest:
return response.Transaction;
case RequestStatus.MoreSignaturesNeeded:
throw new StepUpRequiredException("Balance step up required.");
default:
throw new RequestException(response.Status);
}
}));
}
public GetTransactionResponse getTransaction(string id)
{
GetTransactionRequest request = new GetTransactionRequest();
request.Id = id;
return(coreClient.getTransaction(request));
}
/// <summary>
/// Return Transaction Information
/// </summary>
/// <param name="request">Transaction ID</param>
/// <returns>Transaction Information</returns>
public static GetTransactionResponse GetEmployee(GetTransactionRequest request)
{
GetTransactionResponse response = new GetTransactionResponse();
response.Error = new Handler.ErrorObject();
response.Transaction = new Transactions();
try
{
var bussines = TransactionData.Select.GetTransaction(request.TransactionID);
if (!bussines.Item1.Error)
{
response.Transaction = new Transactions()
{
id = bussines.Item2.id,
amount = bussines.Item2.amount,
idProvide = bussines.Item2.idProvide,
detail = bussines.Item2.detail,
createDate = bussines.Item2.createDate,
upDateDate = bussines.Item2.upDateDate,
deleteDate = bussines.Item2.deleteDate,
state = bussines.Item2.state
};
}
else
{
response.Error.InfoError(bussines.Item1);
}
}
catch (Exception ex)
{
response.Error.InfoError(ex);
}
return(response);
}
public GetTransactionResponse GetTransaction(GetTransactionRequest getTransactionRequest)
{
Log(Logger.LogMessageType.Info, "-> -------------------- Comienza la ejecución del método Sales.GetTransaction", Logger.LoggingLevelType.Medium);
GetTransactionRequestInternal getTransactionRequestInternal = new GetTransactionRequestInternal()
{
SessionID = getTransactionRequest.Request.SessionID,
DeviceType = getTransactionRequest.Request.DeviceType,
ParameterType = (GetTransactionRequestInternalParameterType)getTransactionRequest.Request.ParameterType,
ParameterValue = getTransactionRequest.Request.Parameter
};
GetTransactionResponseInternal internalResponse = GetTransactionInternal(getTransactionRequestInternal);
GetTransactionResponse getTransactionResponse = new GetTransactionResponse();
GetTransactionResponseBody responseBody = new GetTransactionResponseBody()
{
Amount = internalResponse.Amount,
Recipient = internalResponse.Recipient,
ResponseCode = internalResponse.ResponseCode,
ResponseMessage = internalResponse.ResponseMessage,
TransactionDate = internalResponse.TransactionDate,
TransactionID = internalResponse.TransactionID,
TransactionResult = internalResponse.TransactionResult,
TransactionType = internalResponse.TransactionType,
Initiator = internalResponse.Initiator,
Debtor = internalResponse.Debtor,
Creditor = internalResponse.Creditor
};
getTransactionResponse.Response = responseBody;
Log(Logger.LogMessageType.Info, "-> -------------------- Termina la ejecución del método Sales.GetTransaction", Logger.LoggingLevelType.Medium);
return(getTransactionResponse);
}
public async Task <TransactionModel> GetTransactionAsync(GetTransactionRequest request)
{
this.client.DefaultRequestHeaders.Accept.Clear();
this.client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response;
try
{
response = await this.client.GetAsync(
$"http://localhost:38222/api/RPC/callbyname?methodName=getrawtransaction&txid={request.TransactionId}&verbose=1");
}
catch (Exception)
{
throw new WalletServiceException("Failed to connect to node, is it running.");
}
if (!response.IsSuccessStatusCode)
{
throw new WalletServiceException($"Request produced error code {response.StatusCode} from the node, with reason {response.ReasonPhrase}.");
}
if (response.Content == null)
{
throw new WalletServiceException("Response from node contained no content.");
}
var jsonResponse = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <TransactionModel>(jsonResponse));
}
public static GetTransactionsDto ToDto(
this GetTransactionRequest request,
int walletId,
int userId) => new GetTransactionsDto
{
WalletId = walletId,
ReportPeriod = request.ReportPeriod,
CustomFromDate = request.From,
CustomToDate = request.To,
UserId = userId
};
public async Task <TransactionCollection> GetRangedTransactionsAsync(GetTransactionRequest getTransactionRequest)
{
long start = getTransactionRequest.Start.ToUnixTime();
long end = getTransactionRequest.End.ToUnixTime();
string timeUnit = getTransactionRequest.TimeUnit;
try
{
return(await _jobberApi.GetRangedTransactionsAsync(start, end));
}
catch (Exception ex)
{
var errorMessage = $"Failed while getting transactions for last {timeUnit} with start: {start} and end: {end}";
throw ConvertToJobberException(errorMessage, ex);
}
}
private bool SetUnspentTransactionDateTime(
List <UnspentResponse> unspentInNeedOfCoinControl,
CoinControlStatusReport statusReport,
out string errorMessage)
{
GetTransactionRequest transRequest = new GetTransactionRequest()
{
TransactionId = unspentInNeedOfCoinControl[0].TransactionId
};
GetTransactionResponse transResponse;
if (!m_dataConnector.TryPost(transRequest, out transResponse, out errorMessage))
{
return(false);
}
statusReport.UnspentTransactionDateTime = TransactionHelper.GetTransactionTime(transResponse.Time);
return(true);
}
/// <summary>
/// Look up an existing transaction and return the response.
/// </summary>
/// <param name="accountId">the account id</param>
/// <param name="transactionId">the transaction id</param>
/// <param name="keyLevel">the key level</param>
/// <returns>the transaction</returns>
/// <exception cref="StepUpRequiredException">if further authentication is required</exception>
public Task <Transaction> GetTransaction(
string accountId,
string transactionId,
Level keyLevel)
{
var request = new GetTransactionRequest
{
AccountId = accountId,
TransactionId = transactionId
};
return(gateway(authenticateOnBehalfOf(keyLevel)).GetTransactionAsync(request)
.ToTask(response =>
{
if (response.Status.Equals(RequestStatus.SuccessfulRequest))
{
return response.Transaction;
}
throw new StepUpRequiredException("Transaction step up required.");
}));
}
public ApiResponse <Transaction> GetTransaction(GetTransactionRequest request)
{
return(SendApiRequest <GetTransactionRequest, Transaction>(request));
}
public Task <GetTransactionResponse <T> > GetUnconfirmedTransactionAsync <T>(GetTransactionRequest Request) => GetSimpleJsonAsync <GetTransactionResponse <T>, GetTransactionRequest>(Request, Api.GetUnconfirmedTransaction);
public GetTransactionResponse <T> GetUnconfirmedTransaction <T>(GetTransactionRequest Request) => GetUnconfirmedTransactionAsync <T>(Request).GetAwaiter().GetResult();
public async Task <TransactionSummaryResponse> GetTransactionSummary(int walletId, [FromQuery] GetTransactionRequest request)
{
return((await _transactionService.GetSummaryAsync(request.ToDto(walletId, UserId))).ToResponse());
}
public async Task <IEnumerable <TransactionResponse> > GetTransactions(int walletId, [FromQuery] GetTransactionRequest request)
{
List <TransactionDomain> domains = await _transactionService.GetTransactionsAsync(request.ToDto(walletId, UserId));
return(domains.AllToResponse());
}
public GetTransactionResponse GetTransaction(GetTransactionRequest request)
{
return(WrapResponse <GetTransactionResponse, GetTransactionResponseBody>(
new ServiceExecutionDelegator <GetTransactionResponseBody, GetTransactionRequestBody>().ResolveRequest(request.Request, (request.Request.Platform ?? ConfigurationManager.AppSettings["DefaultPlatform"]), ApiServiceName.GetTransaction)));
}
