public async Task <ActionResult> Stream(String id)
{
if (!String.IsNullOrEmpty(id))
{
ViewBag.Id = id;
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
Models.ListStreams.Response response = await client.ListStreams(id);
List <ViewModels.StreamViewModel> streams = new List <ViewModels.StreamViewModel>();
foreach (Models.ListStreams.Result result in response.Result)
{
streams.Add(new ViewModels.StreamViewModel()
{
Chain = id, Name = result.Name, Open = result.Open, Subscribed = result.Subscribed, Synchronised = result.Synchronised
});
}
return(View(streams));
}
}
else
{
throw new ArgumentNullException();
}
}
public async Task <ActionResult> Index()
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
ViewModels.StreamItemsViewModel viewModel = new ViewModels.StreamItemsViewModel();
viewModel.ChainName = id;
viewModel.Stream = stream;
List <Models.DTOs.Access> entities = new List <Models.DTOs.Access>();
var response = await client.ListStreamItems(id, stream);
if (response != null)
{
foreach (Models.ListStreamsItems.Result result in response.Result)
{
//viewModel.Items.Add(result);
Models.DTOs.Access entity = Helpers.SerialisationHelper.ToObject <Models.DTOs.Access>(result.Data);
entities.Add(entity);
}
}
return(View(entities));
}
}
// GET: All stream items
/// <summary>
///
/// </summary>
/// <param name="id">Chain</param>
/// <param name="stream">Stream</param>
/// <returns></returns>
public async Task <ActionResult> Index(String id, String stream)
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
var response = await client.ListStreamItems(id, stream);
return(View(response.Result));
}
}
public async Task <ActionResult> Create(Models.DTOs.Entity dto)
{
//push to chain
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
String hex = Helpers.SerialisationHelper.ToHex(dto);
var response = await client.PublishStreamItem(id, "Entity", dto.Id.ToString(), hex);
ViewBag.Response = "";
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Stream
/// </summary>
/// <param name="id">Chain name</param>
/// <returns></returns>
public async Task <ActionResult> Post(ViewModels.AddStreamKeyValueViewModel viewModel)
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == viewModel.Name);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
//var response = await client.GetStreams(id);
//ViewModels.ChainViewModel model = new ViewModels.ChainViewModel()
//{
// Name = id,
// Version = response.Result.Version,
// Balance = response.Result.Balance
//};
return(View());
}
}
public async Task <ActionResult> Details(String id)
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
var response = await client.GetInfo(id);
ViewModels.ChainViewModel model = new ViewModels.ChainViewModel()
{
Name = id,
Version = response.Result.Version,
Balance = response.Result.Balance
};
return(View(model));
}
}
/// <summary>
/// Get data
/// </summary>
/// <param name="id">Chain</param>
/// <returns></returns>
public async Task <ActionResult> Index()
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
var response = await client.ListStreamItems(id, stream);
List <Models.DTOs.DataEntity> entities = new List <Models.DTOs.DataEntity>();
foreach (Models.ListStreamsItems.Result result in response.Result)
{
Models.DTOs.DataEntity entity = Helpers.SerialisationHelper.ToObject <Models.DTOs.DataEntity>(result.Data);
entities.Add(entity);
}
return(View(entities));
}
}
// GET: All stream items
/// <summary>
///
/// </summary>
/// <param name="id">Chain</param>
/// <param name="stream">Stream</param>
/// <returns></returns>
public async Task <ActionResult> StreamItems(String id, String stream)
{
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == id);
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
ViewModels.StreamItemsViewModel viewModel = new ViewModels.StreamItemsViewModel();
viewModel.ChainName = id;
viewModel.Stream = stream;
var response = await client.ListStreamItems(id, stream);
if (response != null)
{
foreach (Models.ListStreamsItems.Result result in response.Result)
{
viewModel.Items.Add(result);
}
}
return(View(viewModel));
}
}
public async Task <ActionResult> Create(ViewModels.DataEntityViewModel viewModel)
{
if (!String.IsNullOrEmpty(viewModel.Data))
{
Byte[] data = Encoding.ASCII.GetBytes(viewModel.Data);
Byte[] key = Convert.FromBase64String(viewModel.PrivateKey);
Byte[] encryptedData = EncryptByteArray(key, data);
Models.DTOs.DataEntity dataDto = new Models.DTOs.DataEntity()
{
Id = viewModel.Id
};
dataDto.Data = Convert.ToBase64String(encryptedData);
Models.DTOs.Access accessDto = new Models.DTOs.Access()
{
ConsumingEntityId = viewModel.ConsumingEntityId,
PublishingEntityId = viewModel.PublishingEntityId,
DataId = dataDto.Id,
PrivateKey = viewModel.PrivateKey
};
//push to chain
Models.ChainSettings setting = Global.Chains.SingleOrDefault(s => s.Name == "gbst");
using (Clients.Client client = new Clients.Client(setting.Host, setting.RPCUser, setting.RPCPassword, setting.Port))
{
String hex = Helpers.SerialisationHelper.ToHex(dataDto);
var dataTask = client.PublishStreamItem("gbst", "Data", dataDto.Id.ToString(), hex);
var accessTask = client.PublishStreamItem("gbst", "Access", dataDto.Id.ToString(), hex);
await Task.WhenAll(accessTask, dataTask);
}
}
return(View());
}
