public static async Task <(uint, string)> GenerateEncodedContainerRequest(
List <ContainerPermissionsModel> containers,
[Optional] AppExchangeInfo appExchangeInfo)
{
var containerReq = new ContainersReq
{
App = string.IsNullOrWhiteSpace(appExchangeInfo.Name) ? Utilities.GetAppExchangeInfo() : appExchangeInfo,
Containers = new List <ContainerPermissions>()
};
foreach (var item in containers)
{
if (item.IsRequested)
{
containerReq.Containers.Add(new ContainerPermissions
{
ContName = item.ContName,
Access = new PermissionSet
{
Read = item.Access.Read,
Insert = item.Access.Insert,
Delete = item.Access.Delete,
Update = item.Access.Update,
ManagePermissions = item.Access.ManagePermissions,
}
});
}
}
var encodedContainerRequest = await Session.EncodeContainerRequestAsync(containerReq);
return(encodedContainerRequest);
}
public Task <string> EncodeContainersRespAsync(IntPtr auth, ref ContainersReq req, uint reqId, bool isGranted)
{
var reqNative = req.ToNative();
var(ret, userData) = BindingUtils.PrepareTask <string>();
EncodeContainersRespNative(auth, ref reqNative, reqId, isGranted, userData, DelegateOnFfiResultStringCb);
reqNative.Free();
return(ret);
}
public async Task ContainerRequestTest()
{
var authReq = new AuthReq {
App = new AppExchangeInfo {
Id = "net.maidsafe.test", Name = "TestApp", Scope = null, Vendor = "MaidSafe.net Ltd."
},
AppContainer = true,
Containers = new List <ContainerPermissions>()
};
var locator = Utils.GetRandomString(10);
var secret = Utils.GetRandomString(10);
var session = await Utils.CreateTestApp(locator, secret, authReq);
Assert.Throws <FfiException>(() => session.AccessContainer.GetMDataInfoAsync("_public").GetAwaiter().GetResult());
var containerRequest = new ContainersReq {
App = authReq.App,
Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_public", Access = new PermissionSet {
Read = true
}
}
}
};
var(reqId, msg) = await Session.EncodeContainerRequestAsync(containerRequest);
var responseMsg = await Utils.AuthenticateContainerRequest(locator, secret, msg, true);
var ipcMsg = await Session.DecodeIpcMessageAsync(responseMsg);
Assert.AreEqual(typeof(ContainersIpcMsg), ipcMsg.GetType());
var containerResponse = ipcMsg as ContainersIpcMsg;
Assert.AreEqual(reqId, containerResponse?.ReqId);
await session.AccessContainer.RefreshAccessInfoAsync();
var mDataInfo = await session.AccessContainer.GetMDataInfoAsync("_public");
Assert.That(mDataInfo.TypeTag, Is.EqualTo(15000));
session.Dispose();
containerRequest = new ContainersReq {
App = authReq.App,
Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_videos", Access = new PermissionSet {
Read = true
}
}
}
};
(_, msg) = await Session.EncodeContainerRequestAsync(containerRequest);
responseMsg = await Utils.AuthenticateContainerRequest(locator, secret, msg, false);
Assert.That(async() => await Session.DecodeIpcMessageAsync(responseMsg), Throws.TypeOf <IpcMsgException>());
}
public Task <(uint, string)> EncodeContainersReqAsync(ref ContainersReq req)
{
var reqNative = req.ToNative();
var(ret, userData) = BindingUtils.PrepareTask <(uint, string)>();
EncodeContainersReqNative(ref reqNative, userData, DelegateOnFfiResultUIntStringCb);
reqNative.Free();
return(ret);
}
/// <summary>
/// Initialises a Containers request instance.
/// </summary>
/// <param name="reqId">Request Id.</param>
/// <param name="containersReq">Containers request instance.</param>
public ContainersIpcReq(uint reqId, ContainersReq containersReq)
{
ReqId = reqId;
ContainersReq = containersReq;
}
/// <summary>
/// Encodes a container permission request.
/// </summary>
/// <param name="containersReq">Container Request</param>
/// <returns>Request Id, Encoded container request.</returns>
public static Task <(uint, string)> EncodeContainerRequestAsync(ContainersReq containersReq)
{
return(AppBindings.EncodeContainersReqAsync(ref containersReq));
}
