public async Task CreateTransaction_CallswithCorrectParams_Test()
{
var transactionCreatePayload = new DragonchainTransactionCreatePayload
{
Version = "1",
TransactionType = "transaction",
Payload = "hi!",
Tag = "Awesome!"
};
await _dragonchainClient.CreateTransaction(transactionCreatePayload.TransactionType, transactionCreatePayload.Payload, transactionCreatePayload.Tag);
_httpService.Verify(service => service.PostAsync <DragonchainTransactionCreateResponse>("/transaction", It.IsAny <DragonchainTransactionCreatePayload>(), ""), Times.Once);
}
/// <summary>
/// Create a new Transaction on your Dragonchain. This transaction, if properly structured, will be received by your dragonchain,
/// hashed, and put into a queue for processing into a block. The transaction_id returned from this function can be used for checking
/// the status of this transaction. Most importantly; the block in which it has been fixated.
/// </summary>
/// <param name="transactionType">The transaction type to use for this new transaction. This transaction type must already exist on the chain (via `CreateTransactionType`)</param>
/// <param name="payload">Payload of the transaction. Must be a utf-8 encodable string or any object</param>
/// <param name="tag">Tag of the transaction which gets indexed and can be searched on for queries</param>
/// <param name="callbackURL">URL to callback when this transaction is processed</param>
/// <returns></returns>
public async Task <ApiResponse <DragonchainTransactionCreateResponse> > CreateTransaction(string transactionType, object payload = null, string tag = "", string callbackURL = "")
{
if (string.IsNullOrWhiteSpace(transactionType))
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameter `transactionType` is required");
}
if (payload == null)
{
payload = string.Empty;
}
var transactionBody = new DragonchainTransactionCreatePayload
{
Version = "1",
TransactionType = transactionType,
Payload = payload
};
if (!string.IsNullOrWhiteSpace(tag))
{
transactionBody.Tag = tag;
}
return(await _httpService.PostAsync <DragonchainTransactionCreateResponse>("/transaction", transactionBody, callbackURL));
}
/// <summary>
/// Create a bulk transaction to send many transactions to a chain with only a single call
/// </summary>
/// <param name="transactionBulkObject">array of transactions</param>
/// <returns></returns>
public async Task <ApiResponse <DragonchainBulkTransactionCreateResponse> > CreateBulkTransaction(IEnumerable <BulkTransactionPayload> transactionList)
{
if (!transactionList.Any())
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "parameter `transactionList` is required");
}
var bulkTransactionBody = new List <DragonchainTransactionCreatePayload>();
foreach (var transaction in transactionList)
{
var transactionBody = new DragonchainTransactionCreatePayload
{
Version = "1",
TransactionType = transaction.TransactionType,
Payload = transaction.Payload != null ? transaction.Payload : ""
};
if (!string.IsNullOrWhiteSpace(transaction.Tag))
{
transactionBody.Tag = transaction.Tag;
}
bulkTransactionBody.Add(transactionBody);
}
return(await _httpService.PostAsync <DragonchainBulkTransactionCreateResponse>("/transaction_bulk", bulkTransactionBody));
}
