public async Task <BeContractReturn> CallAsync(AdapterServer ads, BeContractCall call)
{
BeContractReturn res = null;
using (var client = new HttpClient())
{
try
{
//Use the ads.Url as baseaddress, don't send this to Be-Road !
client.BaseAddress = new Uri(ads.Url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var httpContent = new StringContent(JsonConvert.SerializeObject(call), Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(ads.Root + "/" + call.Id, httpContent);
if (response.IsSuccessStatusCode)
{
res = await response.Content.ReadAsAsync <BeContractReturn>();
}
}
catch (Exception ex)
{
throw new BeContractException("Cannot call the Adapter Server: " + ex.Message);
}
}
return(res);
}
private BeContractReturn HandleGetOwnerIdByDogId(BeContractCall call)
{
var ret = new BeContractReturn()
{
Id = call.Id,
Outputs = new Dictionary <string, dynamic>()
};
if ((call.Inputs["DogID"] as string).Equals("D-123"))
{
ret.Outputs.Add("OwnerIDOfTheDog", "Wilson !");
}
return(ret);
}
public void ValidateBeContractReturn(BeContract contract, BeContractReturn ret)
{
if (!contract.Id.Equals(ret.Id))
{
throw new BeContractException("Contract's do not have the same ID")
{
BeContract = contract,
BeContractReturn = ret
};
}
//Test outputs
contract.Outputs?.ForEach(output =>
{
if (ret.Outputs.TryGetValue(output.Key, out dynamic value))
{
//Check if the dynamic is a int64
if (value.GetType() == typeof(Int64))
{
value = (int)value;
ret.Outputs[output.Key] = value;
}
//Check the types
if (value.GetType().Name != output.Type)
{
throw new BeContractException($"The contract expects {output.Type} but {value.GetType().Name} was found")
{
BeContract = contract,
BeContractReturn = ret
};
}
}
else
{
//Key isn't find
throw new BeContractException($"No key was found for {output.Key}")
{
BeContract = contract,
BeContractReturn = ret
};
}
});
}
public async Task TestCallPassAsync()
{
var ads = await asService.FindASAsync(call.ISName);
var returnsActual = await asService.CallAsync(ads, call);
var returnsExpected = new BeContractReturn()
{
Id = "GetOwnerIdByDogId",
Outputs = new Dictionary <string, dynamic>()
{
{ "OwnerIDOfTheDog", "Wilson !" }
}
};
CollectionAssert.AreEqual(returnsExpected.Outputs, returnsActual.Outputs);
Assert.AreEqual(returnsExpected.Id, returnsActual.Id);
}
public async Task <BeContractReturn> CallAsync(AdapterServer ads, BeContractCall call)
{
BeContractReturn ret = null;
await Task.Run(() =>
{
switch (ads.ISName)
{
case "Doggies": ret = VeterinaryMock.GetOwnerId(call); break;
case "MathLovers": ret = MathematicsMock.GetSumFunction(call); break;
case "CitizenDatabank": ret = AddressMock.GetAddressByOwnerId(call); break;
default: ret = new BeContractReturn(); break;
}
});
return(ret);
}
/// <summary>
/// Call a contract
/// </summary>
/// <param name="call">The inputs for the contract call</param>
/// <returns></returns>
public async Task <Dictionary <int, BeContractReturn> > CallAsync(BeContractCall call)
{
if (call == null)
{
throw new BeContractException("Contract call is null");
}
var contract = await BcService.FindBeContractByIdAsync(call.Id);
Console.WriteLine($"Calling contract {contract?.Id}");
//Filter to only give the correct outputs
var notFiltredReturns = await CallAndLoopQueriesAsync(call, contract);
var filtredReturns = new Dictionary <int, BeContractReturn>();
var groupedOutputs = contract.Outputs?.GroupBy(output => output.LookupInputId);
groupedOutputs.ToList().ForEach(group =>
{
var beContractReturn = new BeContractReturn
{
Outputs = new Dictionary <string, dynamic>()
};
group.ToList().ForEach(output =>
{
var ret = notFiltredReturns[output.LookupInputId].Outputs.FirstOrDefault(o => o.Key.Equals(output.Key));
beContractReturn.Id = notFiltredReturns[output.LookupInputId].Id;
beContractReturn.Outputs.Add(ret.Key, ret.Value);
});
filtredReturns.Add(group.Key, beContractReturn);
});
filtredReturns.ToList().ForEach(ret =>
{
Console.WriteLine($"At LookupInputId {ret.Key} for contract {ret.Value.Id}");
ret.Value.Outputs.ToList().ForEach(output =>
{
Console.WriteLine($"\t{output.Key} - {output.Value}");
});
});
return(filtredReturns);
}
/// <summary>
/// Call the contract with the specified inputs to a specified service
/// </summary>
/// <param name="contract">Contract that will be called</param>
/// <param name="call">The inputs for the contract</param>
/// <returns>Returns the outputs for that specific contract</returns>
private async Task <BeContractReturn> CallServiceAsync(BeContract contract, BeContractCall call)
{
//Get the ads for this call
var ads = await AsService.FindASAsync(call.Id);
if (ads == null)
{
throw new BeContractException($"No service found for {call.Id}")
{
BeContractCall = call
}
}
;
//Check if the caller has the permission
if (!(await AuthService.CanInformationSystemUseContract(call.ISName, contract)))
{
throw new BeContractException($"The caller {call.ISName} does not have the permission to use {call.Id}")
{
BeContractCall = call,
BeContract = contract
}
}
;
//If everything is fine, call the service
BeContractReturn returns = await AsService.CallAsync(ads, call);
//TODO:
// -Send error to the service
if (returns != null)
{
validators.ValidateBeContractReturn(contract, returns);
}
return(returns);
}
