public async Task CreateContract_CallswithCorrectParams_Test()
{
var body = new SmartContractSchema
{
TransactionType = "name",
Image = "ubuntu:latest",
ExecutionOrder = SmartContractExecutionOrder.Serial,
EnvironmentVariables = new { Banana = "banana", Apple = "banana" },
Cmd = "banana",
Arguments = new string[] { "-m cool" }
};
await _dragonchainClient.CreateSmartContract(body.TransactionType, body.Image, body.Cmd, body.Arguments, (SmartContractExecutionOrder)body.ExecutionOrder, body.EnvironmentVariables);
_httpService.Verify(service => service.PostAsync <DragonchainContractResponse>("/contract", It.IsAny <SmartContractSchema>(), ""), Times.Once);
}
/// <summary>
/// Create a new Smart Contract on your Dragonchain.
/// </summary>
/// <param name="transactionType">Transaction type to assign to this new smart contract. Must not already exist as a transaction type on the chain</param>
/// <param name="image">Docker image to use with the smart contract. Should be in the form registry/image:tag (or just image:tag if it's a docker hub image)</param>
/// <param name="cmd">The command to run in your docker container for your application</param>
/// <param name="args">The list of arguments to use in conjunction with cmd</param>
/// <param name="executionOrder">The execution of the smart contract, can be `serial` or `parallel`. Will default to `parallel`
/// If running in serial, the contract will be queued and executed in order, only one at a time
/// If running in parallel, the contract will be executed as soon as possible after invocation, potentially out of order, and many at a time
/// </param>
/// <param name="environmentVariables">JSON object key-value pairs of strings for environments variables provided to the smart contract on execution</param>
/// <param name="secrets">JSON object key-value pairs of strings for secrets provided to the smart contract on execution
/// These are more securely stored than environment variables, and can be accessed during execution the smart contract by using the `getSmartContractSecret` method of the sdk
/// </param>
/// <param name="scheduleIntervalInSeconds">Schedule a smart contract to be automatically executed every `x` seconds
/// For example: if `10` is supplied, then this contract will be automatically invoked and create a transaction once every 10 seconds
/// Note: This is a mutually exclusive parameter with cronExpression
/// </param>
/// <param name="cronExpression">Schedule a smart contract to be automatically executed on a cadence via a cron expression
/// Note: This is a mutually exclusive parameter with scheduleIntervalInSeconds
/// </param>
/// <param name="registryCredentials">The basic-auth credentials necessary to pull the docker container.
/// This should be a base64-encoded string of `username:password` for the docker registry
/// </param>
/// <returns></returns>
public async Task <ApiResponse <DragonchainContractResponse> > CreateSmartContract(string transactionType,
string image,
string cmd,
IEnumerable <string> args,
SmartContractExecutionOrder executionOrder = SmartContractExecutionOrder.Parallel,
object environmentVariables = null,
object secrets = null,
int?scheduleIntervalInSeconds = null,
string cronExpression = null,
string registryCredentials = null)
{
if (string.IsNullOrWhiteSpace(transactionType))
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameter `transactionType` is required");
}
if (string.IsNullOrWhiteSpace(image))
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameter `image` is required");
}
if (string.IsNullOrWhiteSpace(cmd))
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameter `cmd` is required");
}
if (scheduleIntervalInSeconds != null && cronExpression != null)
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameters `scheduleIntervalInSeconds` and `cronExpression` are mutually exclusive");
}
var body = new SmartContractSchema {
Version = "3",
TransactionType = transactionType,
Image = image,
ExecutionOrder = executionOrder, // default execution order
Cmd = cmd,
Arguments = args,
EnvironmentVariables = environmentVariables,
Secrets = secrets,
Seconds = scheduleIntervalInSeconds,
Cron = cronExpression,
Auth = registryCredentials
};
return(await _httpService.PostAsync <DragonchainContractResponse>("/contract", body));
}
/// <summary>
/// Update an existing Smart Contract on your Dragonchain
/// Note that all parameters (aside from contract id) are optional, and only supplied parameters will be updated
/// </summary>
/// <param name="smartContractId">Smart contract id of which to update. Should be a guid</param>
/// <param name="image">Docker image to use with the smart contract. Should be in the form registry/image:tag (or just image:tag if it's a docker hub image)</param>
/// <param name="cmd">The command to run in your docker container for your application</param>
/// <param name="args">The list of arguments to use in conjunction with cmd</param>
/// <param name="executionOrder">The execution of the smart contract, can be `serial` or `parallel`. Will default to `parallel`
/// If running in serial, the contract will be queued and executed in order, only one at a time
/// If running in parallel, the contract will be executed as soon as possible after invocation, potentially out of order, and many at a time
/// </param>
/// <param name="enabled">Boolean whether or not the contract should be enabled, and able to be invoked</param>
/// <param name="environmentVariables">object key-value pairs of strings for environments variables provided to the smart contract on execution</param>
/// <param name="secrets">object key-value pairs of strings for secrets provided to the smart contract on execution</param>
/// <param name="scheduleIntervalInSeconds">Schedule a smart contract to be automatically executed every `x` seconds
/// For example, if `10` is supplied, then this contract will be automatically invoked and create a transaction once every 10 seconds
/// Note: This is a mutually exclusive parameter with cronExpression
/// </param>
/// <param name="cronExpression">Schedule a smart contract to be automatically executed on a cadence via a cron expression
/// Note: This is a mutually exclusive parameter with scheduleIntervalInSeconds
/// </param>
/// <param name="registryCredentials">The basic-auth credentials necessary to pull the docker container.
/// This should be a base64-encoded string of `username:password` for the docker registry
/// </param>
/// <returns></returns>
public async Task <ApiResponse <DragonchainContractResponse> > UpdateSmartContract(string smartContractId,
string image = null,
string cmd = null,
string[] args = null,
SmartContractExecutionOrder?executionOrder = null,
bool?enabled = null,
object environmentVariables = null,
object secrets = null,
int?scheduleIntervalInSeconds = null,
string cronExpression = null,
string registryCredentials = null)
{
if (string.IsNullOrWhiteSpace(smartContractId))
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameter `smartContractId` is required");
}
if (scheduleIntervalInSeconds != null && cronExpression != null)
{
throw new FailureByDesignException(FailureCode.PARAM_ERROR, "Parameters `scheduleIntervalInSeconds` and `cronExpression` are mutually exclusive");
}
var body = new SmartContractSchema
{
Version = "3",
Image = image,
Cmd = cmd,
ExecutionOrder = executionOrder,
DesiredState = enabled.HasValue ? (enabled == true ? SmartContractDesiredState.Active : SmartContractDesiredState.Inactive) : default(SmartContractDesiredState?),
Arguments = args != null && args.Length > 0 ? args : null,
EnvironmentVariables = environmentVariables != null ? environmentVariables : null,
Secrets = secrets != null ? secrets : null,
Seconds = scheduleIntervalInSeconds != null ? scheduleIntervalInSeconds : null,
Cron = !string.IsNullOrWhiteSpace(cronExpression) ? cronExpression : null,
Auth = !string.IsNullOrWhiteSpace(registryCredentials) ? registryCredentials : null
};
return(await _httpService.PutAsync <DragonchainContractResponse>($"/contract/{smartContractId}", body));
}
