public async Task <HttpResponseMessage> CreateAsync(MT_Block BMD)
{
Db = con.SurgeryCenterDb(BMD.Slug);
BlockResponse Response = new BlockResponse();
try
{
UniqueID = con.GetUniqueKey();
BMD.Block_Unique_ID = UniqueID;
BMD.Block_Create_Date = con.ConvertTimeZone(BMD.Block_TimeZone, Convert.ToDateTime(BMD.Block_Create_Date));
BMD.Block_Modify_Date = con.ConvertTimeZone(BMD.Block_TimeZone, Convert.ToDateTime(BMD.Block_Modify_Date));
DocumentReference docRef = Db.Collection("MT_Block").Document(UniqueID);
WriteResult Result = await docRef.SetAsync(BMD);
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = BMD;
}
else
{
Response.Status = con.StatusNotInsert;
Response.Message = con.MessageNotInsert;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
public async Task <HttpResponseMessage> Remove(MT_Block BMD)
{
Db = con.SurgeryCenterDb(BMD.Slug);
BlockResponse Response = new BlockResponse();
try
{
DocumentReference docRef = Db.Collection("MT_Block").Document(BMD.Block_Unique_ID);
WriteResult Result = await docRef.DeleteAsync();
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = null;
}
else
{
Response.Status = con.StatusNotDeleted;
Response.Message = con.MessageNotDeleted;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
//[Authorize(Roles ="SAdmin")]
public async Task <HttpResponseMessage> GetDeletedList(MT_Block BMD)
{
Db = con.SurgeryCenterDb(BMD.Slug);
BlockResponse Response = new BlockResponse();
try
{
List <MT_Block> AnesList = new List <MT_Block>();
Query docRef = Db.Collection("MT_Block").WhereEqualTo("Block_Is_Deleted", true).OrderBy("Block_Name");
QuerySnapshot ObjQuerySnap = await docRef.GetSnapshotAsync();
if (ObjQuerySnap != null)
{
foreach (DocumentSnapshot Docsnapshot in ObjQuerySnap.Documents)
{
AnesList.Add(Docsnapshot.ConvertTo <MT_Block>());
}
Response.DataList = AnesList;
}
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
// Get Block data
public static InterlockData GetInterlockData(int resourceId, ActionType action = ActionType.Interlock, string username = "", string password = "")
{
var inst = ActionInstances.Find(action, resourceId);
BlockState blockState = null;
if (inst == null)
{
return(new InterlockData(0, null, "No Interlock is associated with this resource."));
}
IPoint point = ServiceProvider.Current.Control.GetPoint(inst.Point);
string message = string.Empty;
int blockId = 0;
try
{
blockId = point.BlockID;
BlockResponse resp = ServiceProvider.Current.Control.GetBlockState(blockId);
blockState = resp.BlockState;
if (blockState == null)
{
message = "Failed to connect with WAGO block.<br />Please try to reload the page and repeat your action again (click the Maintenance tab above).<br />If the problem persists, please contact administrator.";
}
}
catch (Exception ex)
{
message = string.Format("Wago block {0} fault detected. Please contact system administrator. [{0}]", blockId, ex.Message);
}
return(new InterlockData(blockId, blockState, message));
}
public virtual BlockResponse SendGetBlockStateCommand(int blockId)
{
Block block = DA.Current.Single <Block>(blockId);
if (block == null)
{
throw new InvalidOperationException($"Block not found with BlockID = {blockId}");
}
using (var sender = Connect(block))
{
byte[] buffer = CreateGetBlockStateBuffer();
Log.Write(block.BlockID, $"WagoConnection: Sending GetBlockState message to block: BlockID = {block.BlockID}, Data = {WagoUtility.GetDataString(buffer)}");
byte[] recvBuffer = new byte[65];
int bytesRecv = SendMessageToBlock(sender, buffer, recvBuffer, true);
if (bytesRecv > 0)
{
Log.Write(block.BlockID, $"WagoConnection: Received {bytesRecv} bytes [{WagoUtility.BytesToString(recvBuffer, bytesRecv)}] from block {block.BlockID}");
}
else
{
Log.Write(block.BlockID, $"WagoConnection: Block {block.BlockID} did not return any data");
}
BlockResponse result = block.CreateBlockResponse();
result.BlockState.Points = block.Points.Select(x => WagoUtility.GetPointState(x, recvBuffer)).ToArray();
return(result);
}
}
protected virtual void HandleResponses(MessageHeader rp, MemoryStream ms)
{
switch (rp.Operation)
{
case NetOperationType.Hello:
try
{
HelloResponse response = new HelloResponse(ms, rp);
Node.Instance.NodeServers.UpdateNodeServers(response.NodeServers);
OnHelloResponse(response);
}
catch (Exception e)
{
Log.Error(e.Message, e);
}
break;
case NetOperationType.Transactions:
BlockResponse transactionBlockResponse = new BlockResponse(ms, rp);
OnGetBlockResponse(transactionBlockResponse);
break;
case NetOperationType.Blocks:
BlockResponse blockResponse = new BlockResponse(ms, rp);
OnGetBlockResponse(blockResponse);
break;
case NetOperationType.CheckPoint:
break;
}
}
public void testGetResultForBlockByNumber()
{
XooaClient xooaClient = new XooaClient();
xooaClient.setApiToken(XooaConstants.API_TOKEN);
string resultId = "07ce7042-67d8-431f-84a8-fdb3f4145225";
try {
BlockResponse blockResponse = xooaClient.getResultForBlockByNumber(resultId);
Assert.IsNotEmpty(blockResponse.getBlockNumber().ToString());
Assert.IsNotEmpty(blockResponse.getDataHash());
Assert.IsNotEmpty(blockResponse.getNumberOfTransactions().ToString());
Assert.IsNotEmpty(blockResponse.getPreviousHash());
} catch (XooaRequestTimeoutException xrte) {
Assert.IsNotEmpty(xrte.getResultUrl());
Assert.IsNotEmpty(xrte.getResultId());
Assert.AreEqual(resultId, xrte.getResultId());
}
}
public async Task <BlockDto> MapResponseToDtoAsync(BlockResponse blockResponse, bool includeTransactions)
{
var blockDto = _mapper.Map <BlockDto>(blockResponse);
if (!includeTransactions)
{
return(blockDto);
}
var txResponses = await GetTransactionsAsync(blockResponse.TransactionHash, blockResponse.Height);
var txs = txResponses
.Select(x => _mapper.Map <TransactionDto>(x))
.ToList();
for (var i = 0; i < txs.Count; i++)
{
var tx = txs[i];
foreach (var txI in tx.Inputs)
{
txI.TransactionInputOutputType = TransactionInputOutputType.Input;
}
foreach (var txI in tx.Outputs)
{
txI.TransactionInputOutputType = TransactionInputOutputType.Output;
}
switch (i)
{
case 0 when blockDto.Channel == (int)BlockChannels.PoS:
if (tx.Inputs.Any() && tx.Outputs.Any() && tx.Outputs.Count == 1)
{
tx.TransactionType = tx.Inputs.Any(x => tx.Outputs.First().AddressHash == x.AddressHash)
? TransactionType.Coinstake
: TransactionType.CoinstakeGenesis;
}
break;
case 0:
tx.TransactionType = (BlockChannels)blockDto.Channel == BlockChannels.Hash
? TransactionType.CoinbaseHash
: TransactionType.CoinbasePrime;
break;
default:
tx.TransactionType = TransactionType.User;
break;
}
}
blockDto.Transactions = txs;
return(blockDto);
}
/// <summary>
/// Get BlockResponse data for the Result Id.
/// </summary>
/// <exception cref="Xooa.Client.Exception.XooaApiException">Thrown when fails to make API call</exception>
/// <param name="resultId">Result Id of the transaction to fetch data.</param>
/// <param name="timeout">Timeout interval for transaction.</param>
/// <returns>BlockResponse giving the data about the BlockByNumber request.</returns>
public BlockResponse getResultForBlockByNumber(string resultId, string timeout)
{
Log.Info("Invoking URL - " + XooaConstants.RESULT_URL);
var localVarPath = XooaConstants.RESULT_URL;
var contentType = XooaConstants.CONTENT_TYPE;
var localVarQueryParameters = new List <KeyValuePair <string, string> >();
localVarQueryParameters.Add(new KeyValuePair <string, string>(XooaConstants.ASYNC, XooaConstants.FALSE));
localVarQueryParameters.Add(new KeyValuePair <string, string>(XooaConstants.TIMEOUT, timeout));
var localVarHeaderParams = new Dictionary <string, string>();
localVarHeaderParams.Add(XooaConstants.ACCEPT, XooaConstants.CONTENT_TYPE);
localVarHeaderParams.Add(XooaConstants.AUTHORIZATION, XooaConstants.TOKEN + ApiToken);
var localVarPathParams = new Dictionary <string, string>();
localVarPathParams.Add("ResultId", resultId);
int statusCode = 0;
try {
RestRequest request = XooaSDK.Client.Util.Request.PrepareRequest(localVarPath,
RestSharp.Method.GET, localVarQueryParameters, null, localVarHeaderParams,
null, localVarPathParams, contentType);
IRestResponse response = RestClient.Execute(request);
JObject details = XooaSDK.Client.Util.Request.GetData(response);
var payload = details["result"];
BlockResponse blockResponse = new BlockResponse(
payload["previous_hash"].ToString(),
payload["data_hash"].ToString(),
(int)payload["blockNumber"],
(int)payload["numberOfTransactions"]);
return(blockResponse);
} catch (XooaRequestTimeoutException xrte) {
Log.Error(xrte);
throw xrte;
} catch (XooaApiException xae) {
Log.Error(xae);
throw xae;
} catch (System.Exception e) {
Log.Error(e);
throw new XooaApiException(statusCode, e.Message);
}
}
public BlockResponse SendGetBlockStateCommand(int blockId)
{
Block block = DA.Current.Single <Block>(blockId);
try
{
BlockResponse result = block.CreateBlockResponse();
result.BlockState.Points = _points.Where(x => x.BlockID == block.BlockID).ToArray();
return(result);
}
catch (Exception ex)
{
return(block.CreateBlockResponse(ex));
}
}
/// <summary>
/// Get block information for a given hash or height
/// </summary>
/// <param name="id">blockhash or height</param>
/// <returns></returns>
public ActionResult Block(string id)
{
BlockResponse b = _blocks.Get(id);
if (b == null)
{
ExplorerError error = new ExplorerError();
error.Errors.Add("Block not found. Try again or contact us for assistance");
TempData["Errors"] = error;
return(RedirectToAction("Index"));
}
return(View(b));
}
public ActionResult <BlockResponse> Get(string id)
{
if (string.IsNullOrEmpty(id))
{
return(null);
}
var data = (id.Length > 30 && id.Substring(0, 2).Equals("0x")) ?
_dataAdapter.GetBlockByHash(_metadataSchema.DatabaseSchema.TableList.ToArray(), id, "-1") :
_dataAdapter.GetBlockByNumber(_metadataSchema.DatabaseSchema.TableList.ToArray(), id);
if (data == null)
{
return(null);
}
var result = BlockResponse.Default();
result.Data = ResponseWrapper.BlockData(data);
result.Data.Id = id;
result.Data.Attributes.Id = id;
result.Includes = ResponseWrapper.Block(data);
var inh = new Inherents();
var lst = new List <InherentsItem>();
foreach (var item in result.Includes)
{
lst.Add(new InherentsItem {
Id = item.Id,
Type = "extrinsic",
Attributes = item.Attributes
});
}
inh.Data = lst;
result.Data.Relationships = new Relationship
{
Event = new string[] { },
Logs = new string[] { },
Inherents = inh,
Transactions = new string[] { }
};
return(result);
}
public override BlockResponse SendGetBlockStateCommand(int blockId)
{
var block = DA.Current.Single <Block>(blockId);
try
{
using (var sender = Connect(block))
{
byte[] buffer = CreateGetBlockStateBuffer();
Log.Write(block.BlockID, $"WagoConnection: Sending GetBlockState message to block: BlockID = {block.BlockID}, Data = {WagoUtility.GetDataString(buffer)}");
byte[] recvBuffer = new byte[65];
int bytesRecv = SendMessageToBlock(sender, buffer, recvBuffer, true);
if (bytesRecv > 0)
{
Log.Write(block.BlockID, $"WagoConnection: Received {bytesRecv} bytes [{WagoUtility.BytesToString(recvBuffer, bytesRecv)}] from block {block.BlockID}");
}
else
{
Log.Write(block.BlockID, $"WagoConnection: Block {block.BlockID} did not return any data");
}
BlockResponse result = block.CreateBlockResponse();
var testBlock = DA.Current.Query <Block>().First(x => x.BlockName == "wago_test");
result.BlockState.Points = block.Points.Select(x =>
{
var p = new Point()
{
Block = testBlock, ModPosition = 0, Name = x.Name, Offset = x.Offset, PointID = x.PointID
};
return(WagoUtility.GetPointState(p, recvBuffer));
}).ToArray();
return(result);
}
}
catch (Exception ex)
{
return(block.CreateBlockResponse(ex));
}
}
public BlockResponse GetBlockState(int blockId)
{
// Compose Action object
BlockAction action = new BlockAction(blockId);
// Get RequestQueue, and push data into queue
IRequestQueue queue = QueueCollection.Current.Item(blockId);
if (queue == null)
{
throw new InvalidOperationException($"Could not find queue with BlockID {blockId}");
}
// Send request for block state
queue.Push(action);
// Wait a bit for the the response to appear
BlockResponse result = (BlockResponse)queue.GetResponse(action.MessageID);
return(result);
}
public async Task <HttpResponseMessage> UpdateAsync(MT_Block BMD)
{
Db = con.SurgeryCenterDb(BMD.Slug);
BlockResponse Response = new BlockResponse();
try
{
Dictionary <string, object> initialData = new Dictionary <string, object>
{
{ "Block_Type", BMD.Block_Type },
{ "Block_Name", BMD.Block_Name },
{ "Block_Modify_Date", con.ConvertTimeZone(BMD.Block_TimeZone, Convert.ToDateTime(BMD.Block_Modify_Date)) },
{ "Block_Is_Active", BMD.Block_Is_Active },
{ "Block_Is_Deleted", BMD.Block_Is_Deleted }
};
DocumentReference docRef = Db.Collection("MT_Block").Document(BMD.Block_Unique_ID);
WriteResult Result = await docRef.UpdateAsync(initialData);
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = BMD;
}
else
{
Response.Status = con.StatusNotUpdate;
Response.Message = con.MessageNotUpdate;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
public async Task <BlockResponse> GetListBlock(string strToken)
{
BlockResponse respData = null;
try
{
string Url = GetUrlListBlock(strToken);
HttpClient client = new HttpClient();
HttpResponseMessage responseMessage = await client.GetAsync(Url);
if (responseMessage.StatusCode == System.Net.HttpStatusCode.OK)
{
string result = await responseMessage.Content.ReadAsStringAsync();
respData = JsonConvert.DeserializeObject <BlockResponse>(result);
}
}
catch (Exception ex)
{
throw ex;
}
return(respData);
}
public void testGetBlockByNumber()
{
XooaClient xooaClient = new XooaClient();
xooaClient.setApiToken(XooaConstants.API_TOKEN);
try {
BlockResponse br = xooaClient.getBlockByNumber("10");
Assert.IsNotNull(br.getBlockNumber());
Assert.IsNotEmpty(br.getDataHash());
Assert.IsNotEmpty(br.getPreviousHash());
Assert.IsNotNull(br.getNumberOfTransactions());
Assert.AreEqual(10, br.getBlockNumber(), "Block Numbers do not match");
} catch (XooaRequestTimeoutException xrte) {
Assert.IsNotEmpty(xrte.getResultId());
Assert.IsNotEmpty(xrte.getResultUrl());
}
}
public BlockResponseEventArgs(BlockResponse blockResponse)
{
BlockResponse = blockResponse;
}
protected virtual void HandleRequests(MessageHeader rp, MemoryStream ms)
{
switch (rp.Operation)
{
case NetOperationType.Blocks:
BlockRequest blockRequest = new BlockRequest(ms, rp);
var blockResponse = new BlockResponse
{
RequestId = blockRequest.RequestId,
Blocks = BlockChain.Instance.GetBlocks(blockRequest.StartBlock, blockRequest.EndBlock)
};
using (MemoryStream memoryStream = new MemoryStream())
{
blockResponse.SaveToStream(memoryStream);
memoryStream.Position = 0;
SendRaw(memoryStream);
}
break;
case NetOperationType.Transactions:
{
BlockRequest transactionBlockRequest = new BlockRequest(ms, rp);
BlockResponse transactionBlockResponse = new BlockResponse
{
RequestId = transactionBlockRequest.RequestId,
Blocks = BlockChain.Instance.GetBlocks(transactionBlockRequest.StartBlock,
transactionBlockRequest.EndBlock).ToList()
};
using (MemoryStream memoryStream = new MemoryStream())
{
transactionBlockResponse.SaveToStream(memoryStream);
memoryStream.Position = 0;
SendRaw(memoryStream);
}
break;
}
case NetOperationType.CheckPoint:
break;
case NetOperationType.Hello:
HelloRequest request = new HelloRequest(ms, rp);
Node.Instance.NodeServers.UpdateNodeServers(request.NodeServers);
HelloResponse response = new HelloResponse(request)
{
Timestamp = DateTime.UtcNow,
Error = 0,
ServerPort = Node.NetParams.Port,
Block = BlockChain.Instance.GetLastBlock(),
WorkSum = CheckPoints.WorkSum,
AccountKey = Node.Instance.NodeKey,
RequestType = RequestType.Response,
Operation = NetOperationType.Hello
};
using (MemoryStream vm = new MemoryStream())
{
response.SaveToStream(vm);
vm.Position = 0;
SendRaw(vm);
}
break;
}
}
protected virtual void OnGetBlockResponse(BlockResponse blockResponse)
{
BlockResponse?.Invoke(this, new BlockResponseEventArgs(blockResponse));
}
private void FillToolStatusTable(DataTable dtToolStatus)
{
DataRow row = null;
if (!dtToolStatus.Columns.Contains("PointID"))
{
dtToolStatus.Columns.Add("PointID", typeof(int));
}
if (!dtToolStatus.Columns.Contains("InterlockStatus"))
{
dtToolStatus.Columns.Add("InterlockStatus", typeof(string));
}
if (!dtToolStatus.Columns.Contains("InterlockState"))
{
dtToolStatus.Columns.Add("InterlockState", typeof(bool));
}
if (!dtToolStatus.Columns.Contains("InterlockError"))
{
dtToolStatus.Columns.Add("InterlockError", typeof(bool));
}
if (!dtToolStatus.Columns.Contains("IsInterlocked"))
{
dtToolStatus.Columns.Add("IsInterlocked", typeof(bool));
}
int blockId = 0;
BlockState blockState;
var blocks = Session.Query <Block>().ToList();
Dictionary <int, BlockState> dict = new Dictionary <int, BlockState>();
var points = Session.Query <Point>().ToList();
var interlocks = Session.Query <ActionInstance>().Where(x => x.ActionName == "Interlock").ToList();
foreach (DataRow dr in dtToolStatus.Rows)
{
row = dr;
blockState = null;
if (dr["ResourceID"] != DBNull.Value)
{
dr.SetField("InterlockStatus", "Blank");
dr.SetField("InterlockState", false);
dr.SetField("InterlockError", false);
dr.SetField("IsInterlocked", true);
if (dr["PointID"] == DBNull.Value)
{
var inst = interlocks.FirstOrDefault(x => x.ActionID == row.Field <int>("ResourceID"));
if (inst != null)
{
dr.SetField("PointID", inst.Point);
}
else
{
dr.SetField("PointID", 0);
}
}
int pointId = dr.Field <int>("PointID");
if (pointId > 0)
{
Point point = points.First(x => x.PointID == pointId);
blockId = point.Block.BlockID;
if (dict.ContainsKey(blockId))
{
blockState = dict[blockId];
if (blockState == null)
{
row.SetField("InterlockStatus", "Wago block fault detected.");
row.SetField("InterlockError", true);
}
}
else
{
//We try to get returned data
try
{
BlockResponse resp = GetBlockState(blockId);
blockState = resp.EnsureSuccess().BlockState;
}
catch (Exception ex)
{
string errmsg = ex.ToString();
row.SetField("InterlockStatus", "Wago block fault detected.");
row.SetField("InterlockError", true);
}
//blockState might be null here if there was a fault but that's ok
dict.Add(blockId, blockState);
}
if (blockState != null)
{
bool pointState = blockState.GetPointState(point.PointID);
row.SetField("InterlockState", pointState);
if (pointState)
{
row.SetField("InterlockStatus", "Tool Enabled");
}
else
{
row.SetField("InterlockStatus", "Tool Disabled");
}
}
}
else
{
//this is not an error
row.SetField("InterlockStatus", "No interlock for resource.");
row.SetField("IsInterlocked", false);
}
}
}
}
public static BlockState GetBlockState(int blockId)
{
BlockResponse resp = ServiceProvider.Current.Control.GetBlockState(blockId);
return(resp.EnsureSuccess().BlockState);
}
