public async Task <Response> Invoke(byte[] serializedRequest)
{
var deserializedRequest = _serializer.RequestSerializer.DeserializeRequest <TContract>(serializedRequest);
var response = await ContractParser <TContract> .Invoke(_instance, _serializer.ResponseSerializer, deserializedRequest.Method, deserializedRequest.Args.Values.ToArray());
return(response);
}
static TimerBoundaryEvent CreateTimeBoundaryEvent(XElement xElement)
{
var timerBoundaryEvent = new TimerBoundaryEvent();
FillCommonProcessElementAttributes(timerBoundaryEvent, xElement);
timerBoundaryEvent.AttachedTo = GetAttachedToElement(xElement);
var xTimerDefinitionType = xElement.Element("DefinitionType");
if (xTimerDefinitionType == null)
{
throw new InvalidElementException($"Timer event at line {ContractParser.GetLineNumber(xElement)} " +
$"is missing timer definition type");
}
if (Enum.TryParse(xTimerDefinitionType.Value, out TimerDefinitionType parsedDefinitionType))
{
timerBoundaryEvent.TimerDefinitionType = parsedDefinitionType;
}
else
{
throw new InvalidElementException($"{xTimerDefinitionType.Value} is not a valid timer definition type at " +
$"line {ContractParser.GetLineNumber(xTimerDefinitionType)}");
}
var xTimerDefinition = xElement.Element("Definition");
if (xTimerDefinition == null)
{
throw new InvalidElementException($"Timer event at line {ContractParser.GetLineNumber(xElement)} " +
$"is missing timer definition");
}
timerBoundaryEvent.TimerDefinition = xTimerDefinition.Value;
return(timerBoundaryEvent);
}
public void Convert()
{
var contract = ContractParser.FromDasFile("C:\\Users\\Johny\\Downloads\\mortgage.dascontract");
var contractConverter = new ContractConverter(contract);
contractConverter.ConvertContract();
File.WriteAllText("C:\\Users\\Johny\\Downloads\\mortgage.sol", contractConverter.GetSolidityCode());
}
public void GivenValidFilePath_AndValidContent_ThenFileIsParsed()
{
var contractParser = new ContractParser();
var contractDefinition = contractParser.ParseFile("./TestFiles/website-api.json");
Assert.That(contractDefinition, Is.Not.Null);
Assert.That(contractDefinition.Consumer, Is.EqualTo("website"));
Assert.That(contractDefinition.Provider, Is.EqualTo("api"));
Assert.That(contractDefinition.Contracts.Count(), Is.Not.EqualTo(0));
}
public void GivenValidFilePath_WhenFileIsPactSpecification_AndValidContent_ThenFileIsParsed()
{
var contractParser = new ContractParser();
var contractDefinition = contractParser.ParseFile("./TestFiles/pact-specification.json", true);
Assert.That(contractDefinition, Is.Not.Null);
Assert.That(contractDefinition.Consumer, Is.EqualTo("website"));
Assert.That(contractDefinition.Provider, Is.EqualTo("api"));
Assert.That(contractDefinition.Contracts.Count(), Is.EqualTo(1));
}
/// <summary>
/// Serializes the request.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="request">The request.</param>
/// <returns></returns>
public byte[] SerializeRequest <TService>(Request request)
{
var methodKey = ContractParser <TService> .GetMethodKey(request.Method);
JObject message = new JObject();
message[methodKey] = new JObject();
for (int i = 0; i < request.Args.Count; i++)
{
message[methodKey][i.ToString()] = JToken.FromObject(request.Args[i]);
}
return(Encoding.UTF8.GetBytes(message.ToString()));
}
static string GetAttachedToElement(XElement xElement, bool mandatory = true)
{
var xAttachedTo = xElement.Element("AttachedTo");
if (xAttachedTo != null)
{
return(xAttachedTo.Value);
}
if (mandatory)
{
throw new InvalidElementException($"Element at line {ContractParser.GetLineNumber(xElement)} " +
$"is missing attached to definition");
}
return(null);
}
static CallActivity CreateCallActivity(XElement xElement)
{
var callActivity = new CallActivity();
FillCommonTaskAttributes(callActivity, xElement);
var xCalledElement = xElement.Element("CalledElement");
if (xCalledElement == null)
{
throw new InvalidElementException($"CallActivity at line {ContractParser.GetLineNumber(xElement)} " +
$"is missing called element definition");
}
callActivity.CalledElement = xCalledElement.Value;
return(callActivity);
}
/// <summary>
/// Deserializes the request.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="serializedRequest">The serialized request.</param>
/// <returns></returns>
public Request DeserializeRequest <TService>(byte[] serializedRequest)
{
var stringMessage = Encoding.UTF8.GetString(serializedRequest);
JObject message = JObject.Parse(stringMessage);
var properties = message.Properties();
var key = message.Properties().FirstOrDefault().Name;
var method = ContractParser <TService> .GetMethod(key);
object[] args = message.Value <JObject>(key)
.Properties()
.OrderBy(x => int.Parse(x.Name))
.Select(x => x.Value.ToObject(ContractParser <TService> .GetPropertyType(key, x.Name)))
.ToArray();
return(new Request(method, args));
}
static SequenceFlow CreateSequenceFlow(XElement xSequenceFlow)
{
var sequenceFlow = new SequenceFlow();
var xIdElement = xSequenceFlow.Element("Id");
var xNameElement = xSequenceFlow.Element("Name");
var xSourceElement = xSequenceFlow.Element("SourceId");
var xTargetElement = xSequenceFlow.Element("TargetId");
if (xIdElement != null)
{
sequenceFlow.Id = xIdElement.Value;
}
else
{
throw new InvalidElementException($"Sequence flow at line {ContractParser.GetLineNumber(xSequenceFlow)} is missing an ID");
}
if (xSourceElement != null)
{
sequenceFlow.SourceId = xSourceElement.Value;
}
else
{
throw new InvalidElementException($"Sequence flow at line {ContractParser.GetLineNumber(xSequenceFlow)} is missing a source");
}
if (xTargetElement != null)
{
sequenceFlow.TargetId = xTargetElement.Value;
}
else
{
throw new InvalidElementException($"Sequence flow at line {ContractParser.GetLineNumber(xSequenceFlow)} is missing a target");
}
if (xNameElement != null)
{
sequenceFlow.Name = xNameElement.Value;
sequenceFlow.Condition = xNameElement.Value;
}
return(sequenceFlow);
}
static void FillCommonTaskAttributes(Task task, XElement xElement)
{
FillCommonProcessElementAttributes(task, xElement);
var xInstanceType = xElement.Element("InstanceType");
if (xInstanceType == null)
{
task.InstanceType = InstanceType.Single;
}
else if (Enum.TryParse(xInstanceType.Value, out InstanceType parsedInstanceType))
{
task.InstanceType = parsedInstanceType;
}
else
{
throw new InvalidElementException($"{xInstanceType.Value} is not a valid instance type value at line" +
$"{ContractParser.GetLineNumber(xInstanceType)}");
}
var xLoopCardinality = xElement.Element("LoopCardinality");
if (xLoopCardinality != null)
{
if (int.TryParse(xLoopCardinality.Value, out var parsedLoopCardinality))
{
task.LoopCardinality = parsedLoopCardinality;
}
else
{
throw new InvalidElementException($"loop cardinality at {ContractParser.GetLineNumber(xInstanceType)} " +
$"must be an integer");
}
}
var xLoopCollection = xElement.Element("LoopCollection");
if (xLoopCollection != null)
{
task.LoopCollection = xLoopCollection.Value;
}
}
static void FillCommonPayableTaskAttributes(PayableTask payableTask, XElement xElement)
{
FillCommonTaskAttributes(payableTask, xElement);
var xTokenOperationType = xElement.Element("OperationType");
if (xTokenOperationType == null)
{
payableTask.OperationType = TokenOperationType.None;
}
else if (Enum.TryParse(xTokenOperationType.Value, out TokenOperationType parsedTokenOperationType))
{
payableTask.OperationType = parsedTokenOperationType;
}
else
{
throw new InvalidElementException($"{xTokenOperationType.Value} is not a valid token operation type value at line" +
$"{ContractParser.GetLineNumber(xTokenOperationType)}");
}
}
static string GetProcessId(XElement xElement)
{
var xIdElement = xElement.Element("Id");
if (xIdElement == null)
{
throw new InvalidElementException($"Id not set for process element on line {ContractParser.GetLineNumber(xElement)}");
}
return(xIdElement.Value);
}
static ProcessElement CreateProcessElement(XElement xElement)
{
ProcessElement processElement;
var xElementAttribute = xElement.Attribute(XMLNS + "type");
if (xElementAttribute == null)
{
throw new InvalidElementException($"Mandatory attribute for a process element not found at line {ContractParser.GetLineNumber(xElement)}");
}
switch (xElementAttribute.Value)
{
case "ContractBusinessRuleTask":
processElement = CreateBusinessRuleTask(xElement);
break;
case "ContractScriptActivity":
processElement = CreateScriptTask(xElement);
break;
case "ContractServiceActivity":
processElement = CreateServiceTask(xElement);
break;
case "ContractUserActivity":
processElement = CreateUserTask(xElement);
break;
case "ContractStartEvent":
processElement = CreateStartEvent(xElement);
break;
case "ContractEndEvent":
processElement = CreateEndEvent(xElement);
break;
case "ContractExclusiveGateway":
processElement = CreateExclusiveGateway(xElement);
break;
case "ContractParallelGateway":
processElement = CreateParallelGateway(xElement);
break;
case "ContractTimerBoundaryEvent":
processElement = CreateTimeBoundaryEvent(xElement);
break;
case "ContractCallActivity":
processElement = CreateCallActivity(xElement);
break;
default:
throw new InvalidElementException($"{xElementAttribute.Value} is not a valid process element type at line {ContractParser.GetLineNumber(xElement)}");
}
return(processElement);
}
public void SetUp()
{
contract = ContractParser.Parse(CorrectContractTableLine.Split(','));
parser = () => ContractParser.Parse(invalidContractRow.Split(','));
}
