private B2BSERAWebService.Model.DownloadDocumentViewModel DownloadDocumentResponse(List <TransactionViewModel> listData)
{
DownloadDocumentViewModel DownloadDocumentResult = new DownloadDocumentViewModel();
DownloadDocumentResult.Acknowledge = true;
DownloadDocumentResult.TicketNo = "EDE283E6BE1A866452AC76F106CC5CB80BA1902F0BBA8C019F27D3E5025C931139B8E385AD37F6E1CDA0FB029A1198E17DD968A5C711A1FFFB72F33405F34B8EA545F4CE02F7B8B83369C36AC83BF0FAE422B15B919D294047AEC92AF8DC67A0";
DownloadDocumentResult.Message = "Download Data Succeeded";
List <TransactionDataModel> trans = new List <TransactionDataModel>();
for (int i = 0; i < listData.Count; i++)
{
TransactionDataModel transData = new TransactionDataModel();
transData.ID = listData[i].TransactionDataID;
transData.TransGUID = listData[i].TransGUID;
transData.DocumentNumber = listData[i].DocumentNumber;
transData.FileType = listData[i].FileType;
transData.IPAddress = listData[i].IPAddress;
transData.DestinationUser = listData[i].DestinationUser;
transData.DataLength = listData[i].DataLength;
//TODO 2013-09-05: BUILD { Data = HS|PONUMBER|||||||| }
List <string> listString = new List <string>();
TransactionProvider transactionProvider = UnityContainerHelper.Container.Resolve <TransactionProvider>();
listString = transactionProvider.SearchTransDetail(listData[i].TransactionDataID);
transData.Data = listString.ToArray();
trans.Add(transData);
}
DownloadDocumentResult.transactionData = trans;
return(DownloadDocumentResult);
}
public async Task <IResponse <NoValue> > AddToTransaction(TransactionDataModel model)
{
var response = new Response <NoValue>();
var transactions = new List <Transaction>();
try
{
var jobTimeline = _entity.JobTimeline.Find(model.JobId);
var fromAdapter = jobTimeline.Schedule.JobDefinition.Adapter;
var toAdapter = jobTimeline.Schedule.JobDefinition.Adapter1;
var transactionList = model.Data;
//remove intersecting transactions if job is recurrent
var newTransactionsResponse = RemoveIntersection(model.Data, jobTimeline);
if (newTransactionsResponse.Value.Count > 0)
{
foreach (var transaction in newTransactionsResponse.Value)
{
var transactionTypeResponse = GetTransactionType(transaction);
var accountsResponse = await _accountService.GetAccount(transaction.TransactionAccount, fromAdapter.EnterpriseAdapter.FirstOrDefault().Id, toAdapter.CryptoAdapter.FirstOrDefault().Id);
transactions.Add(new Transaction
{
TransactionId = transaction.TransactionId,
AccountId = accountsResponse.Value.Id,
TransactionAmount = Math.Abs(Convert.ToDecimal(transaction.TransactionAmount)),
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
TransactionTypeId = transactionTypeResponse.Value.Id,
TransactionStatusId = (int)Common.Enums.TransactionStatus.Pending,
JobTimelineId = model.JobId,
});
}
_entity.Transaction.AddRange(transactions);
_entity.SaveChanges();
}
response.Status = Common.Enums.StatusEnum.Success;
}
catch (Exception ex)
{
response.Message = Message.SomethingWentWrong;
response.Status = Common.Enums.StatusEnum.Error;
_logger.Information($"TransactionService.AddToTransaction(model: {model})");
_logger.Error(ex.Message);
}
return(response);
}
public async Task ExecuteJob(long jobId)
{
try
{
_jobHistoryService.ChangeJobStatus(JobStatus.Executing, jobId);
var status = new StatusEnum();
var jobTimeline = _entity.JobTimeline.Find(jobId);
var jobDefinitionId = jobTimeline.Schedule.JobDefinition.Id;
var fromAdapter = jobTimeline.Schedule.JobDefinition.Adapter;
string fromBlock;
string toBlock;
string address;
int ethLimit = Int32.Parse(_configuration["Limits:EthereumBlocks"]);
int btcLimit = Int32.Parse(_configuration["Limits:BitcoinBlocks"]);
int neoLimit = Int32.Parse(_configuration["Limits:NEOBlocks"]);
int ltcLimit = Int32.Parse(_configuration["Limits:LitecoinBlocks"]);
switch ((AdapterTypeItemEnum)fromAdapter.AdapterTypeItemId)
{
case AdapterTypeItemEnum.MSSQL:
case AdapterTypeItemEnum.MySQL:
case AdapterTypeItemEnum.Oracle:
var data = _dbAdapterService.GetAdapterData(jobDefinitionId);
if (data.Status == StatusEnum.Success && data.Value.Count > 0)
{
var transactionData = new TransactionDataModel
{
JobId = jobId,
Data = data.Value
};
await _transactionService.AddToTransaction(transactionData);
var transactions = _transactionService.GetTransactionsWithoutHash(jobId);
if (transactions.Status == StatusEnum.Success)
{
var blockchainDataList = new List <BlockchainDataModel>()
{
new BlockchainDataModel
{
JobId = jobId,
Transactions = transactions.Value
}
};
status = await SendData(jobId, blockchainDataList);
break;
}
}
status = StatusEnum.Error;
break;
case AdapterTypeItemEnum.MongoDB:
break;
case AdapterTypeItemEnum.Ethereum:
fromBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.FromBlock).Value;
toBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.ToBlock).Value;
address = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.EthereumAccount).Value;
int fromBlockConverted;
int toBlockConverted;
Int32.TryParse(fromBlock, out fromBlockConverted);
Int32.TryParse(toBlock, out toBlockConverted);
var ethereumCurrentBlock = await _blockchainService.GetCurrentBlockNumber(fromAdapter.Id, AdapterTypeItemEnum.Ethereum);
if (ethereumCurrentBlock.Status == StatusEnum.Success)
{
if (fromBlockConverted == 0)
{
fromBlockConverted = 1;
}
if (toBlockConverted == 0)
{
toBlockConverted = ethereumCurrentBlock.Value;
}
if (Math.Abs(toBlockConverted - fromBlockConverted) < ethLimit && fromBlockConverted < ethereumCurrentBlock.Value && toBlockConverted <= ethereumCurrentBlock.Value)
{
var blocks = await _blockchainService.GetBlocksWithTransactions <EthereumBlockModel>(fromAdapter.Id, fromBlockConverted, toBlockConverted, address);
if (blocks.Status == StatusEnum.Success)
{
status = await SendData(jobId, blocks.Value);
if (status != StatusEnum.Error)
{
if (jobTimeline.Schedule.RecurrenceRule != null)
{
_blockTransactionService.AddBlocksWithTransactions(jobId, blocks.Value);
}
break;
}
}
status = StatusEnum.Error;
break;
}
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId, limitExceeded: true);
break;
}
status = StatusEnum.Error;
break;
case AdapterTypeItemEnum.Cardano:
case AdapterTypeItemEnum.EOS:
break;
case AdapterTypeItemEnum.NEO:
fromBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.FromBlock).Value;
toBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.ToBlock).Value;
address = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.NeoAddress).Value;
Int32.TryParse(fromBlock, out fromBlockConverted);
Int32.TryParse(toBlock, out toBlockConverted);
var neoCurrentBlock = await _blockchainService.GetCurrentBlockNumber(fromAdapter.Id, AdapterTypeItemEnum.NEO);
if (neoCurrentBlock.Status == StatusEnum.Success)
{
if (fromBlockConverted == 0)
{
fromBlockConverted = 1;
}
if (toBlockConverted == 0)
{
toBlockConverted = neoCurrentBlock.Value;
}
if (Math.Abs(toBlockConverted - fromBlockConverted) < neoLimit && fromBlockConverted < neoCurrentBlock.Value && toBlockConverted <= neoCurrentBlock.Value)
{
var neoBlocks = await _blockchainService.GetBlocksWithTransactions <NeoBlockModel>(fromAdapter.Id, fromBlockConverted, toBlockConverted, address);
if (neoBlocks.Status == StatusEnum.Success)
{
status = await SendData(jobId, neoBlocks.Value);
if (status != StatusEnum.Error)
{
if (jobTimeline.Schedule.RecurrenceRule != null)
{
_blockTransactionService.AddBlocksWithTransactions(jobId, neoBlocks.Value);
}
break;
}
}
status = StatusEnum.Error;
break;
}
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId, limitExceeded: true);
break;
}
status = StatusEnum.Error;
break;
case AdapterTypeItemEnum.Bitcoin:
fromBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.FromBlock).Value;
toBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.ToBlock).Value;
address = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.BitcoinAddress).Value;
Int32.TryParse(fromBlock, out fromBlockConverted);
Int32.TryParse(toBlock, out toBlockConverted);
var bitcoinCurrentBlock = await _blockchainService.GetCurrentBlockNumber(fromAdapter.Id, AdapterTypeItemEnum.Bitcoin);
if (bitcoinCurrentBlock.Status == StatusEnum.Success)
{
if (fromBlockConverted == 0)
{
fromBlockConverted = 1;
}
if (toBlockConverted == 0)
{
toBlockConverted = bitcoinCurrentBlock.Value;
}
if (Math.Abs(toBlockConverted - fromBlockConverted) < btcLimit && fromBlockConverted < bitcoinCurrentBlock.Value && toBlockConverted <= bitcoinCurrentBlock.Value)
{
var bitcoinBlocks = await _blockchainService.GetBlocksWithTransactions <BitcoinBlockModel>(fromAdapter.Id, fromBlockConverted, toBlockConverted, address);
if (bitcoinBlocks.Status == StatusEnum.Success)
{
status = await SendData(jobId, bitcoinBlocks.Value);
if (status != StatusEnum.Error)
{
if (jobTimeline.Schedule.RecurrenceRule != null)
{
_blockTransactionService.AddBlocksWithTransactions(jobId, bitcoinBlocks.Value);
}
break;
}
}
status = StatusEnum.Error;
break;
}
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId, limitExceeded: true);
break;
}
status = StatusEnum.Error;
break;
case AdapterTypeItemEnum.Litecoin:
fromBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.FromBlock).Value;
toBlock = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.ToBlock).Value;
address = jobTimeline.Schedule.JobDefinition.JobDefinitionProperty.FirstOrDefault(jdp => jdp.PropertyId == (long)PropertyEnum.LitecoinAddress).Value;
Int32.TryParse(fromBlock, out fromBlockConverted);
Int32.TryParse(toBlock, out toBlockConverted);
var litecoinCurrentBlock = await _blockchainService.GetCurrentBlockNumber(fromAdapter.Id, AdapterTypeItemEnum.Litecoin);
if (litecoinCurrentBlock.Status == StatusEnum.Success)
{
if (fromBlockConverted == 0)
{
fromBlockConverted = 1;
}
if (toBlockConverted == 0)
{
toBlockConverted = litecoinCurrentBlock.Value;
}
if (Math.Abs(toBlockConverted - fromBlockConverted) < ltcLimit && fromBlockConverted < litecoinCurrentBlock.Value && toBlockConverted <= litecoinCurrentBlock.Value)
{
var litecoinBlocks = await _blockchainService.GetBlocksWithTransactions <LitecoinBlockModel>(fromAdapter.Id, fromBlockConverted, toBlockConverted, address);
if (litecoinBlocks.Status == StatusEnum.Success)
{
status = await SendData(jobId, litecoinBlocks.Value);
if (status != StatusEnum.Error)
{
if (jobTimeline.Schedule.RecurrenceRule != null)
{
_blockTransactionService.AddBlocksWithTransactions(jobId, litecoinBlocks.Value);
}
break;
}
}
status = StatusEnum.Error;
break;
}
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId, limitExceeded: true);
break;
}
status = StatusEnum.Error;
break;
case AdapterTypeItemEnum.Excel:
case AdapterTypeItemEnum.MATLAB:
break;
default:
status = StatusEnum.Error;
break;
}
if (status == StatusEnum.Error)
{
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId);
}
}
catch (Exception ex)
{
_jobHistoryService.ChangeJobStatus(JobStatus.Failed, jobId);
_logger.Information($"JobService.ExecuteJob(jobId: {jobId})");
_logger.Error(ex.Message);
}
}
